/*

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

*

*/

#include "vibraactionplugin.h"

#include <cfactionindication.h>

#include "vibratrace.h"

#include "vibraaction.h"

// CONSTANTS

// Security policy for vibra action

_LIT_SECURITY_POLICY_PASS( KSecurityPolicy );

// Vibra actions

_LIT( KVibraAction, "Vibra" );

// Vibra parameters

_LIT( KVibraMode, "Mode" );

_LIT( KVibraDelay, "Delay" );

_LIT( KVibraRepeats, "Repeats" );

_LIT( KVibraRepeatInterval, "RepeatInterval" );

_LIT( KVibraDuration, "Duration" );

_LIT( KVibraIntensity, "Intensity" );

// Vibra mode values

_LIT( KVibraStart, "Start" );

_LIT( KVibraStop, "Stop" );

#ifdef _DEBUG

// Panic category

_LIT( KPanicCat, "VibraAction" );

// Panic codes

enum TPanicCode

    {

    EVibraActionNotInitialized

    };

// Local panic function

LOCAL_C void Panic( TPanicCode aCode )

    {

    User::Panic( KPanicCat, aCode );

    }

#endif

// MEMBER FUNCTIONS

CVibraActionPlugIn* CVibraActionPlugIn::NewL()

    {

    FUNC_LOG;

    CVibraActionPlugIn* self = CVibraActionPlugIn::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

CVibraActionPlugIn* CVibraActionPlugIn::NewLC()

    {

    FUNC_LOG;

    CVibraActionPlugIn* self = new( ELeave ) CVibraActionPlugIn;

    CleanupStack::PushL( self );

    return self;

    }

// Destructor

CVibraActionPlugIn::~CVibraActionPlugIn()

    {

    FUNC_LOG;

    delete iVibraAction;

    }

CVibraActionPlugIn::CVibraActionPlugIn()

    {

    FUNC_LOG;

    // Nothing to do

    }

// METHODS

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

// CVibraActionPlugIn::InitializeL

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

//

void CVibraActionPlugIn::InitializeL()

    {

    FUNC_LOG;

    iVibraAction = CVibraAction::NewL( *this );

    }

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

// CVibraActionPlugIn::ExecuteL

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

//

CCFActionPlugIn::TExecutionTime CVibraActionPlugIn::ExecuteL(

    CCFActionIndication* aActionIndication )

    {

    FUNC_LOG;

    CCFActionPlugIn::TExecutionTime time = CCFActionPlugIn::ENone;

    __ASSERT_DEBUG( iVibraAction, Panic( EVibraActionNotInitialized ) );

    // Parse settings

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

    TInt count = parameters.Count();

    TPtrC key( KNullDesC );

    TPtrC value( KNullDesC );

    TVibraActionInfo info;

    TPtrC mode( KNullDesC );

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

        {

        key.Set( parameters[i]->Key() );

        value.Set( parameters[i]->Value() );

        // Mode

        if( key.CompareF( KVibraMode ) == KErrNone )

            {

            mode.Set( value );

            INFO_1( "Vibra mode: %S", &mode );

            }

        // Delay

        else if( key.CompareF( KVibraDelay ) == KErrNone )

            {

            info.iDelay = ConvertToInt( value );

            INFO_1( "Vibra delay: %d", info.iDelay );

            }

        // Repeats

        else if( key.CompareF( KVibraRepeats ) == KErrNone )

            {

            info.iRepeats = ConvertToInt( value );

            INFO_1( "Vibra repeats: %d", info.iRepeats );

            }

        // Repeat interval

        else if( key.CompareF( KVibraRepeatInterval ) == KErrNone )

            {

            info.iRepeatInterval = ConvertToInt( value );

            INFO_1( "Vibra repeat interval: %d", info.iRepeatInterval );

            }

        // Duration

        else if( key.CompareF( KVibraDuration ) == KErrNone )

            {

            info.iDuration = ConvertToInt( value );

            INFO_1( "Vibra duration: %d", info.iDuration );

            }

        // Intensity

        else if( key.CompareF( KVibraIntensity ) == KErrNone )

            {

            info.iIntensity = ConvertToInt( value );

            INFO_1( "Vibra intensity: %d", info.iIntensity );

            }

        }

    // Start vibra

    if( mode.CompareF( KVibraStart ) == KErrNone )

        {

        // Check if we have to repeat vibra pulses

        // In this case we must not return with ENone since

        // action execution thread will start waiting in semaphore

        // and none of the active objects will then be run

        time = iVibraAction->StartVibraL( info );

        }

    // Stop vibra

    else if( mode.CompareF( KVibraStop ) == KErrNone )

        {

        iVibraAction->StopVibraL();

        }

    return time;

    }

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

// CVibraActionPlugIn::GetActionsL

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

//

void CVibraActionPlugIn::GetActionsL( CDesCArray& aActionList ) const

    {

    FUNC_LOG;

    aActionList.AppendL( KVibraAction );

    }

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

// CVibraActionPlugIn::SecurityPolicy

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

//

const TSecurityPolicy& CVibraActionPlugIn::SecurityPolicy() const

    {

    FUNC_LOG;

    return KSecurityPolicy;

    }

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

// CVibraActionPlugIn::VibraActionCompletedL

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

//

void CVibraActionPlugIn::VibraActionCompletedL()

    {

    FUNC_LOG;

    AsyncExecutionCompleted();

    }

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

// CVibraActionPlugIn::ConvertToInt

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

//

TInt CVibraActionPlugIn::ConvertToInt( const TDesC& aDesc ) const

    {

    FUNC_LOG;

    TInt value = 0;

    TLex lex( aDesc );

    if( lex.Val( value ) != KErrNone )

        {

        value = KErrNotFound;

        }

    return value;

    }