/*

* Copyright (c) 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:  Class for producing vibra feedback.

* Part of:      Tactile Feedback.

*

*/

#include <e32debug.h>

#include <hwrmvibra.h>

#include <centralrepository.h>

#include <ecom/implementationproxy.h>

#include <ProfileInternal.hrh>

#include "tactilefeedbackprivatecrkeys.h"

#include "tactilefeedbacktrace.h"

#include "tactilevibraplayer.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "tactilevibraplayerTraces.h"

#endif

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

// Constructor.

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

//

CTactileVibraPlayer::CTactileVibraPlayer( CRepository& aRepository ):

        iRepository ( aRepository )

    {    

    }

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

// 2nd phase constructor.

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

//

void CTactileVibraPlayer::ConstructL()

    {

    TRACE("CTactileVibraPlayer::ConstructL - Begin");

    User::LeaveIfError( iRepository.Get( KTactileFeedbackHapticsStrength, 

                                         iVibraLevel ) );

    if ( iVibraLevel > EProfileTactileFeedbackLevel5 )

        {

        User::Leave( KErrGeneral );

        }

    ReadSettings();

    iCenRepNotifier = CCenRepNotifyHandler::NewL( *this, 

                                                  iRepository, 

                                                  CCenRepNotifyHandler::EIntKey,

                                                  KTactileFeedbackHapticsStrength );

    iCenRepNotifier->StartListeningL();     

    TRACE("CTactileVibraPlayer::ConstructL - End");

    }

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

// 2-phased constructor.

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

//

CTactileVibraPlayer* CTactileVibraPlayer::NewL( CRepository& aRepository )

    {

    CTactileVibraPlayer* self = 

        new ( ELeave ) CTactileVibraPlayer ( aRepository );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor.

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

//

CTactileVibraPlayer::~CTactileVibraPlayer()

    {

    delete iCenRepNotifier;

    delete iVibra;

    iVibraParams.Close();

    }

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

// From class CTactilePlayer

//

// Duration and intensity for the vibra are selected from the array

// according to logical feedback type.

//

// Feedback is not produced in case duration or intensity is zero.

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

//

TInt CTactileVibraPlayer::PlayFeedback( TTouchLogicalFeedback aFeedback )

    {

    TInt ret(KErrNotReady);

    if ( iVibraLevel != EProfileTactileFeedbackOff )

        {

        TInt effectIndex = KErrNotFound;

        switch ( aFeedback )

            {

            case ETouchFeedbackBasic:               // flow through

            case ETouchFeedbackBasicButton:         // flow through

            case ETouchFeedbackBasicItem:           // flow through

            case ETouchFeedbackBounceEffect:        // flow through

            case ETouchFeedbackBasicSlider:         // flow through

            case ETouchFeedbackEditor:              // flow through

            case ETouchFeedbackLineSelection:       // flow through

            case ETouchFeedbackBlankSelection:      // flow through

            case ETouchFeedbackTextSelection:       // flow through

            case ETouchFeedbackEmptyLineSelection:  // flow through

            case ETouchFeedbackPopUp:               // flow through

            case ETouchFeedbackPopupOpen:           // flow through

            case ETouchFeedbackPopupClose:          // flow through

            case ETouchFeedbackItemScroll:          // flow through

            case ETouchFeedbackCheckbox:            // flow through

            case ETouchFeedbackMultitouchActivate:

            case ETouchFeedbackBasicKeypad:

            case ETouchFeedbackFlick:

            case ETouchFeedbackItemDrop:

            case ETouchFeedbackItemMoveOver:

            case ETouchFeedbackItemPick:

            case ETouchFeedbackMultipleCheckbox:

            case ETouchFeedbackRotateStep:

            case ETouchFeedbackStopFlick:

            case ETouchFeedbackLongPress:

                effectIndex = 0;

                break;

            case ETouchFeedbackSensitive:           // flow through

            case ETouchFeedbackSensitiveButton:     // flow through

            case ETouchFeedbackSensitiveItem:      

            case ETouchFeedbackSensitiveKeypad:

            case ETouchFeedbackSensitiveSlider:

                effectIndex = 1;                    

                break;                              

            default:                                

                effectIndex = 0;                    

                break;                              

            }

        if ( effectIndex < iVibraParams.Count() && 

             iVibraParams[effectIndex].iTime > 0 &&

             iVibraParams[effectIndex].iIntensity != 0)

            {

            TRACE2("CTactileVibraPlayer::PlayFeedback %d", aFeedback);  

            TRAP( ret, DoPlayFeedbackL( 

                iVibraParams[effectIndex].iTime, 

                iVibraParams[effectIndex].iIntensity ) ); 

            if (!ret)    

                {

                TRACE2("CTactileVibraPlayer: Vibra playing leave code: %d", ret);  

                }

            }        

        }

    return ret;

    }

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

// Start feedback.

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

//   

TInt CTactileVibraPlayer::StartFeedback( TTouchContinuousFeedback aType,

                                         TInt aIntensity )

    {

    TRACE("CTactileVibraPlayer::StartFeedback - Begin");

    TRAPD( ret, DoStartFeedbackL( aType, aIntensity ) );

    TRACE("CTactileVibraPlayer::StartFeedback - End");

    return ret;

    }

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

// Modify feedback.

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

//                        

TInt CTactileVibraPlayer::ModifyFeedback( TInt /*aIntensity*/ )

    {

    return KErrNotSupported;

    }

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

// Stop feedback.

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

//    

void CTactileVibraPlayer::StopFeedback()

    {

    TRACE("CTactileVibraPlayer::StopFeedback - Begin");

    if ( iVibra )

        {

        TRAP_IGNORE( iVibra->StopVibraL() );

        }    

    TRACE("CTactileVibraPlayer::StopFeedback - End");

    }

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

//

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

//    

TInt CTactileVibraPlayer::PlayPreviewFeedback( TInt aLevel, 

                                             TTouchLogicalFeedback aFeedback )    

    {

    TRACE("CTactileVibraPlayer::PlayPreviewFeedback - Begin");

    TInt ret( KErrArgument );

    if ( aLevel > EProfileTactileFeedbackOff  &&

         aLevel <= EProfileTactileFeedbackLevel5 )

        {

        iOriginalLevel = iVibraLevel;

        iVibraLevel = aLevel;

        ReadSettings();    

        ret = PlayFeedback( aFeedback );

        iVibraLevel = iOriginalLevel;

        ReadSettings();

        }    

    TRACE("CTactileVibraPlayer::PlayPreviewFeedback - End");

    return ret;    

    }

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

// Read vibra effects from central repository.

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

//

void CTactileVibraPlayer::ReadSettings()

    {    

    TRACE("CTactileVibraPlayer::ReadSettings - Begin");

    TTactileVibraParams basicParams;

    basicParams.iTime = 0;

    basicParams.iIntensity = 0;

    TTactileVibraParams sensitiveParams = basicParams;

    if ( iVibraLevel == EProfileTactileFeedbackLevel1 )

        {

        // Read settings for ETouchFeedbackBasic

        iRepository.Get( KTactileVibraIntensityBasicLevel1, 

                          basicParams.iIntensity );

        iRepository.Get( KTactileVibraDurationBasicLevel1,  

                          basicParams.iTime );

        // Read settings for ETouchFeedbackSensitive

        iRepository.Get( KTactileVibraIntensitySensitiveLevel1, 

                          sensitiveParams.iIntensity );

        iRepository.Get( KTactileVibraDurationSensitiveLevel1,  

                          sensitiveParams.iTime );

        }

    else if ( iVibraLevel == EProfileTactileFeedbackLevel2 )

        {

        // Read settings for ETouchFeedbackBasic

        iRepository.Get( KTactileVibraIntensityBasicLevel2, 

                          basicParams.iIntensity );

        iRepository.Get( KTactileVibraDurationBasicLevel2,  

                          basicParams.iTime );

        // Read settings for ETouchFeedbackSensitive

        iRepository.Get( KTactileVibraIntensitySensitiveLevel2, 

                          sensitiveParams.iIntensity );

        iRepository.Get( KTactileVibraDurationSensitiveLevel2,  

                          sensitiveParams.iTime );

        }

    else if ( iVibraLevel == EProfileTactileFeedbackLevel3 )

        {

        // Read settings for ETouchFeedbackBasic

        iRepository.Get( KTactileVibraIntensityBasicLevel3, 

                          basicParams.iIntensity );

        iRepository.Get( KTactileVibraDurationBasicLevel3,  

                          basicParams.iTime );

        // Read settings for ETouchFeedbackSensitive

        iRepository.Get( KTactileVibraIntensitySensitiveLevel3, 

                          sensitiveParams.iIntensity );

        iRepository.Get( KTactileVibraDurationSensitiveLevel3,  

                          sensitiveParams.iTime );

        }

    else if ( iVibraLevel == EProfileTactileFeedbackLevel4 )

        {

        // Read settings for ETouchFeedbackBasic

        iRepository.Get( KTactileVibraIntensityBasicLevel4, 

                          basicParams.iIntensity );

        iRepository.Get( KTactileVibraDurationBasicLevel4,  

                          basicParams.iTime );

        // Read settings for ETouchFeedbackSensitive

        iRepository.Get( KTactileVibraIntensitySensitiveLevel4, 

                          sensitiveParams.iIntensity );

        iRepository.Get( KTactileVibraDurationSensitiveLevel4,  

                          sensitiveParams.iTime );

        }

    else if ( iVibraLevel == EProfileTactileFeedbackLevel5 )

        {

        // Read settings for ETouchFeedbackBasic

        iRepository.Get( KTactileVibraIntensityBasicLevel5, 

                          basicParams.iIntensity );

        iRepository.Get( KTactileVibraDurationBasicLevel5,  

                          basicParams.iTime );

        // Read settings for ETouchFeedbackSensitive

        iRepository.Get( KTactileVibraIntensitySensitiveLevel5, 

                          sensitiveParams.iIntensity );

        iRepository.Get( KTactileVibraDurationSensitiveLevel5,  

                          sensitiveParams.iTime );

        }

    iVibraParams.Reset();

    TRACE("CTactileVibraPlayer::ReadSettings - End");      

    }    

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

// Actually play feedback.

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

//

void CTactileVibraPlayer::DoPlayFeedbackL( TInt aTime, TInt aIntensity )

    {

    TRACE("CTactileVibraPlayer::DoPlayFeedbackL - Begin");

    if ( !iVibra )

        {

        // Construct iVibra at first feedback request.

        iVibra = CHWRMVibra::NewL();

        }

    TRACE("CTactileVibraPlayer::DoPlayFeedbackL - Starting Vibra");

    OstTrace0( TACTILE_PERFORMANCE, TACTILE_PLAY_VIBRA_FEEDBACK_1, "e_TACTILE_PLAY_VIBRA_FEEDBACK 1");

    iVibra->PulseVibraL( aTime, aIntensity ); 

    OstTrace0( TACTILE_PERFORMANCE, TACTILE_PLAY_VIBRA_FEEDBACK_0, "e_TACTILE_PLAY_VIBRA_FEEDBACK 0");

    TRACE("CTactileVibraPlayer::DoPlayFeedbackL - End");

    }

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

//

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

//    

void CTactileVibraPlayer::DoStartFeedbackL( TTouchContinuousFeedback /*aType*/,

                                            TInt /*aIntensity*/ )

    {

    if ( !iVibra )

        {

        // Construct iVibra at first feedback request.

        iVibra = CHWRMVibra::NewL();

        }    

    if ( iVibraParams.Count() )

        {

        TRACE2("CTactileVibraPlayer: StartVibraL  Duration: %d", KHWRMVibraMaxDuration ); 

        TRACE2("CTactileVibraPlayer: StartVibraL  Intensity: %d", iVibraParams[0].iIntensity );

        iVibra->StartVibraL( KHWRMVibraMaxDuration, 

                             iVibraParams[0].iIntensity );

        }    

    }                                            

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

// From MCenRepNotifyHandlerCallback.

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

//    

void CTactileVibraPlayer::HandleNotifyInt( TUint32 aId, TInt aNewValue )    

    {

    TRACE("CTactileVibraPlayer::HandleNotifyInt - Begin");

    if ( aId == KTactileFeedbackHapticsStrength )

        {

        iVibraLevel = aNewValue;

        if ( iVibraLevel != EProfileTactileFeedbackOff )

            {

            ReadSettings();    

            }

        }

    TRACE("CTactileVibraPlayer::HandleNotifyInt - End");

    }

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

// ImplementationTable[]

//

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

//

const TImplementationProxy ImplementationTable[] = 

    {

    IMPLEMENTATION_PROXY_ENTRY( 0x2001CB9B, CTactileVibraPlayer::NewL )

    };

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

// TImplementationProxy* ImplementationGroupProxy()

//

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

//

EXPORT_C const TImplementationProxy* ImplementationGroupProxy( TInt& aTableCount )

    {

    aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy);

    return ImplementationTable;

    }

// End of file