/*

* 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 haptics feedback.

* Part of:      Tactile Feedback.

*

*/

#include <f32file.h>

#include <e32debug.h>

#include <hwrmhaptics.h>

#include <centralrepository.h>

#include <ecom/implementationproxy.h>

#include <MProfileEngine.h>

#include <MProfile.h>

#include <MProfileExtraSettings.h>

#include <MProfileFeedbackSettings.h>

#include <CProfileChangeNotifyHandler.h>

#include "tactilefeedbackprivatecrkeys.h"

#include "tactilefeedbacktrace.h"

#include "tactilehapticsplayer.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "tactilehapticsplayerTraces.h"

#endif

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

const TInt KMaxEffectNameLen = 128;

// Pulse feedback's names

_LIT8( KTFBasic,                "TFBasic");

_LIT8( KTFSensitive,            "TFSensitive");

_LIT8( KTFBasicButton,          "TFBasicButton");

_LIT8( KTFSensitiveButton,      "TFSensitiveButton");

_LIT8( KTFList,                 "TFList");

_LIT8( KTFSensitiveList,        "TFSensitiveList");

_LIT8( KTFBoundaryList,         "TFBoundaryList");

_LIT8( KTFSlider,               "TFSlider");

_LIT8( KTFEdit,                 "TFEdit");

_LIT8( KTFLineSelection,        "TFLineSelection");

_LIT8( KTFBlankSelection,       "TFBlankSelection");

_LIT8( KTFTextSelection,        "TFTextSelection");

_LIT8( KTFEmptyLineSelection,   "TFEmptyLineSelection");

_LIT8( KTFTab,                  "TFTab");

_LIT8( KTFPopUp,                "TFPopUp");

_LIT8( KTFIncreasingPopUp,      "TFIncreasingPopUp");

_LIT8( KTFDecreasingPopUp,      "TFDecreasingPopUp");

_LIT8( KTFFlick,                "TFFlick");

_LIT8( KTFCheckbox,             "TFCheckbox");

_LIT8( KTFSensitiveInput,       "TFSensitiveInput");

_LIT8( KTFCharacterInputButton, "TFCharacterInputButton");

_LIT8( KTFOptionsMenuOpened,    "TFOptionsMenuOpened");

_LIT8( KTFOptionsMenuClosed,    "TFOptionsMenuClosed");

_LIT8( KTFSubMenuOpened,        "TFSubMenuOpened");

_LIT8( KTFSubMenuClosed,        "TFSubMenuClosed");

_LIT8( KTFLongTap,              "TFLongTap");

_LIT8( KTFMultiTouchRecognized, "TFMultiTouchRecognized");

// Continuous feedback's names

_LIT8( KTFContinuousSmooth,     "TFContinuousSmooth");

_LIT8( KTFContinuousSlider,     "TFContinuousSlider");

_LIT8( KTFContinuousInput,      "TFContinuousInput");

_LIT8( KTFContinuousFlick,      "TFContinuousFlick");

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

// Constructor.

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

//

CTactileHapticsPlayer::CTactileHapticsPlayer( CRepository& aRepository ) :

    iRepository(aRepository)

    {

    }

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

// 2nd phase constructor.

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

//

void CTactileHapticsPlayer::ConstructL()

    {

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

    iHaptics = CHWRMHaptics::NewL(NULL, NULL); 

    TUint32 suppMask( 0 );

    User::LeaveIfError( iHaptics->SupportedActuators( suppMask ) );

    TInt actuatorType( EHWRMLogicalActuatorAny );    

    iRepository.Get( KTactileFeedbackHapticsActuator, actuatorType );

    if ( actuatorType & suppMask )

        {

        iHaptics->OpenActuatorL( static_cast<THWRMLogicalActuators>(actuatorType) );    

        }    

    User::LeaveIfError( iHaptics->SetDeviceProperty( 

                                        CHWRMHaptics::EHWRMHapticsLicensekey, 

                                        KNullDesC8() ) );

    TInt strength(0);

    iRepository.Get( KTactileFeedbackHapticsStrength, strength );

    // Strength value in settings is multiplied by 100 to scale value 

    // suitable for haptics (0-10000).    

    iStrength = strength * 100;

    // As a temporary fix to EAKH-7LKANT, the strength is (over)read from

    // profiles engine

    InitializeProfilesEngineL();

        {

        User::Leave( KErrGeneral );

        }

    User::LeaveIfError( iHaptics->SetDeviceProperty( 

                                        CHWRMHaptics::EHWRMHapticsStrength, 

                                        iStrength ) );

    TFileName ivtFile;

    if ( iVibraLevel != EProfileTactileFeedbackOff )

        {

        iRepository.Get( IVTFileId(), ivtFile );

        }

    else

        {

        // Load KTactileHapticsLevel1IVTFile as default IVT file

        // to start up if vibra level is EProfileTactileFeedbackOff.

        iRepository.Get( KTactileHapticsLevel1IVTFile, ivtFile );

        }

    HBufC8* ivtBuf = IVTBufAllocL( ivtFile );

    CleanupStack::PushL( ivtBuf );

    User::LeaveIfError( iHaptics->LoadEffectData( *ivtBuf, iIVTHandle ) );

    CleanupStack::PopAndDestroy( ivtBuf );

    iCenRepNotifier = CCenRepNotifyHandler::NewL( *this, 

                                                  iRepository );

    iCenRepNotifier->StartListeningL();    

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

    }

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

// 2-phased constructor.

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

//

CTactileHapticsPlayer* CTactileHapticsPlayer::NewL( CRepository& aRepository )

    {

    CTactileHapticsPlayer* self = 

                        new ( ELeave ) CTactileHapticsPlayer( aRepository );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor.

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

//

CTactileHapticsPlayer::~CTactileHapticsPlayer()

    {

    if( iProfileEng )

        {

        iProfileEng->Release();

        iProfileEng = NULL;

        }

    delete iProfileHandler;

    delete iCenRepNotifier;

    delete iHaptics;

    }

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

// From class CTactilePlayer

//

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

//

TInt CTactileHapticsPlayer::PlayFeedback( TTouchLogicalFeedback aFeedback )

    {

    // TRACE("CTactileHapticsPlayer::PlayFeedback - Start");

    TRACE2("CTactileHapticsPlayer::PlayFeedback type: %d", aFeedback );

    TRAPD( err, DoPlayFeedbackL( aFeedback )); 

    if ( err != KErrNone )

        {

        TRACE2("CTactileHapticsPlayer::PlayFeedback error: %d", err );

        }    

    // TRACE("CTactileHapticsPlayer::PlayFeedback - End");

    return err;

    }

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

// Actually play feedback.

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

//

void CTactileHapticsPlayer::DoPlayFeedbackL( TTouchLogicalFeedback aFeedback )

    {

    // Check if hapticts strength is set to zero or

    // vibra level is EProfileTactileFeedbackOff.

    if ( !iStrength || iVibraLevel == EProfileTactileFeedbackOff)

        {

        User::Leave(KErrNotReady);

        }

    TBuf8<KMaxEffectNameLen> name;

    switch( aFeedback )

        {

        case ETouchFeedbackBasic:

            name = KTFBasic;

            break;

        case ETouchFeedbackSensitive:

            name = KTFSensitive;

            break;

        case ETouchFeedbackBasicButton:

            name = KTFBasicButton;

            break;

        case ETouchFeedbackSensitiveButton:

            name = KTFSensitiveButton;

            break;

        case ETouchFeedbackList:

            name = KTFList;

            break;

        case ETouchFeedbackSensitiveList:

            name = KTFSensitiveList;

            break;

        case ETouchFeedbackBoundaryList:

            name = KTFBoundaryList;

            break;

        case ETouchFeedbackSlider:

            name = KTFSlider;

            break;

        case ETouchFeedbackEdit:

            name = KTFEdit;

            break;

        case ETouchFeedbackLineSelection:

            name = KTFLineSelection;

            break;

        case ETouchFeedbackBlankSelection:

            name = KTFBlankSelection;

            break;

        case ETouchFeedbackTextSelection:

            name = KTFTextSelection;

            break;

        case ETouchFeedbackEmptyLineSelection:

            name = KTFEmptyLineSelection;

            break;                        

        case ETouchFeedbackTab:

            name = KTFTab;

            break;

        case ETouchFeedbackPopUp:  

            name = KTFPopUp;

            break; 

       case ETouchFeedbackIncreasingPopUp:

            name = KTFIncreasingPopUp;

            break;     

        case ETouchFeedbackDecreasingPopUp:

            name = KTFDecreasingPopUp;

            break;

        case ETouchFeedbackFlick:

            name = KTFFlick;

            break;

        case ETouchFeedbackCheckbox:

            name = KTFCheckbox;

            break;

        case ETouchFeedbackSensitiveInput:

            name = KTFSensitiveInput;

            break;

        case ETouchFeedbackCharacterInputButton:

            name = KTFCharacterInputButton;

            break;

        case ETouchFeedbackOptionsMenuOpened:

            name = KTFOptionsMenuOpened;

            break;

        case ETouchFeedbackOptionsMenuClosed:

            name = KTFOptionsMenuClosed;

            break;

        case ETouchFeedbackSubMenuOpened:

            name = KTFSubMenuOpened;

            break;

        case ETouchFeedbackSubMenuClosed:

            name = KTFSubMenuClosed;

            break;

        case ETouchFeedbackLongTap:

            name = KTFLongTap;

            break;

        case ETouchFeedbackMultiTouchRecognized:

            name = KTFMultiTouchRecognized;

            break;

        default:

            User::Leave( KErrArgument );

            break;

        }

    TInt effectIndex(0);

    User::LeaveIfError( iHaptics->GetEffectIndexFromName( iIVTHandle, 

                                                          name, 

                                                          effectIndex ) );

    TInt effectHandle(0);

    OstTrace0( TACTILE_PERFORMANCE, TACTILE_PLAY_HAPTICS_FEEDBACK_1, "e_TACTILE_PLAY_HAPTICS_FEEDBACK 1");

    User::LeaveIfError( iHaptics->PlayEffect( iIVTHandle, 

                                              effectIndex, 

                                              effectHandle ) );

    OstTrace0( TACTILE_PERFORMANCE, TACTILE_PLAY_HAPTICS_FEEDBACK_0, "e_TACTILE_PLAY_HAPTICS_FEEDBACK 0");

    }

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

// Get IVT file Id via vibra level.

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

//

TUint32 CTactileHapticsPlayer::IVTFileId()

    {

    TUint32 fileId = 0;

    switch ( iVibraLevel )

        {

        case EProfileTactileFeedbackLevel1:

            fileId = KTactileHapticsLevel1IVTFile;

            break;

        case EProfileTactileFeedbackLevel2:

            fileId = KTactileHapticsLevel2IVTFile;

            break;

        case EProfileTactileFeedbackLevel3:

            fileId = KTactileHapticsLevel3IVTFile;

            break;

        }

    return fileId;

    }

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

// Load IVT file.

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

//

HBufC8* CTactileHapticsPlayer::IVTBufAllocL( const TDesC& aFileName )

    {

    TRACE("CTactileHapticsPlayer::IVTBufAllocL - Begin");

    RFs fs;

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

    CleanupClosePushL( fs );

    RFile file;

    User::LeaveIfError( file.Open( fs, aFileName, EFileRead ) );

    CleanupClosePushL( file );

    TInt fileSize( 0 );

    file.Size( fileSize );

    HBufC8* ivtFileBuf = HBufC8::NewLC( fileSize );

    TPtr8 dataBufPtr = ivtFileBuf->Des();

    User::LeaveIfError( file.Read( dataBufPtr ) );

    CleanupStack::Pop( ivtFileBuf );    

    CleanupStack::PopAndDestroy( &file );

    CleanupStack::PopAndDestroy( &fs );

    TRACE("CTactileHapticsPlayer::IVTBufAllocL - End");

    return ivtFileBuf;

    }

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

// Start feedback.

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

//   

TInt CTactileHapticsPlayer::StartFeedback( TTouchContinuousFeedback aFeedback,

                                           TInt aIntensity )

    {

    TRACE("CTactileHapticsPlayer::StartFeedback - Start");

    TInt ret(KErrNone);

    // If there's an ongoing feedback, stop it first.

    if ( iEffectHandle )

        {

        StopFeedback();

        }

    TBuf8<KMaxEffectNameLen> name;   

    switch( aFeedback )

        {

        case ETouchContinuousSmooth:

            name = KTFContinuousSmooth;

            break;

        case ETouchContinuousSlider:

            name = KTFContinuousSlider;

            break;               

        case ETouchContinuousInput:

            name = KTFContinuousInput;

            break;

        case ETouchContinuousFlick:

            name = KTFContinuousFlick;

            break;    

        default:

            ret = KErrArgument;

            break;

        }

    if ( ret == KErrNone )

        {

        ret = iHaptics->GetEffectIndexFromName( iIVTHandle, 

                                                name, 

                                                iEffectIndex );        

        }

    TInt effectType(0);

    if ( ret == KErrNone )

        {    

        ret = iHaptics->GetEffectType( iIVTHandle, 

                                       iEffectIndex, 

                                       effectType );

        }           

    if ( ret == KErrNone )

        {

        switch ( effectType )                               

            {

            case CHWRMHaptics::EHWRMHapticsTypePeriodic:

                {

                CHWRMHaptics::THWRMHapticsPeriodicEffect periodicDef;

                ret = iHaptics->GetPeriodicEffectDefinition( iIVTHandle,

                                                             iEffectIndex,

                                                             periodicDef );

                // Effect's magnitude value in IVT file is used as max value for 

                // continuous effects and Attack level is used as minimum value

                iMultiplier = ( periodicDef.iMagnitude - periodicDef.iAttackLevel ) / 100;

                periodicDef.iMagnitude = aIntensity * iMultiplier + periodicDef.iAttackLevel;

                if ( ret == KErrNone )

                    {

                    ret = iHaptics->PlayPeriodicEffect( periodicDef,

                                                        iEffectHandle );

                    }

                }

                break;

            case CHWRMHaptics::EHWRMHapticsTypeMagSweep:

                {

                CHWRMHaptics::THWRMHapticsMagSweepEffect magSweepDef;

                ret =iHaptics->GetMagSweepEffectDefinition( iIVTHandle,

                                                            iEffectIndex,

                                                            magSweepDef );

                // Effect's magnitude value in IVT file is used as max value for

                // continuous effects and Attack level is used as minimum value

                iMultiplier = ( magSweepDef.iMagnitude - magSweepDef.iAttackLevel ) / 100;

                magSweepDef.iMagnitude = aIntensity * iMultiplier + magSweepDef.iAttackLevel;

                if ( ret == KErrNone )

                    {

                    ret =iHaptics->PlayMagSweepEffect( magSweepDef,

                                                       iEffectHandle );  

                    }

                }

                break;            

            default:

                TRACE("CTactileHapticsPlayer::StartFeedback - Playing effect not found");

                ret = KErrArgument;

                break;

            }            

        }  

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

    return ret;     

    }

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

// Modify feedback.

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

//                        

TInt CTactileHapticsPlayer::ModifyFeedback( TInt aIntensity )

    {

    TRACE("CTactileHapticsPlayer::ModifyFeedback - Start");

    TInt ret(KErrNotReady);

    // Check if there's feedback started, do nothing if not.

    if ( iEffectHandle )

        {

        TInt effectType(0);

        ret = iHaptics->GetEffectType( iIVTHandle, 

                                       iEffectIndex, 

                                       effectType );

        TRACE2("CTactileHapticsPlayer::ModifyFeedback - effect type %d", effectType );

        if ( ret == KErrNone )

            {

            TInt intensity = aIntensity * iMultiplier;

            switch ( effectType )                               

                {

                case CHWRMHaptics::EHWRMHapticsTypePeriodic:

                    {

                    CHWRMHaptics::THWRMHapticsPeriodicEffect periodicDef;

                    iHaptics->GetPeriodicEffectDefinition( iIVTHandle,

                                                           iEffectIndex,

                                                           periodicDef );

                    periodicDef.iMagnitude = intensity + periodicDef.iAttackLevel;

                    iHaptics->ModifyPlayingPeriodicEffect( iEffectHandle, 

                                                           periodicDef );            

                    }

                    break;

                case CHWRMHaptics::EHWRMHapticsTypeMagSweep: