/*

* Copyright (c) 2007-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:  Class for resolving physical feedback type based on 

*                tactile feedback settings and current device state.

* Part of:      Tactile Feedback.

*

*/

#include <e32base.h>

#include <e32std.h>

#include <e32debug.h>

#include <centralrepository.h>

#include <ecom/implementationinformation.h>

#include <ProfileEngineInternalCRKeys.h>

#include "tactilefeedbackprivatecrkeys.h"

#include "tactilefeedbackinternalpskeys.h"

#include "tactilefeedbacktrace.h"

#include "tactilefeedbackresolver.h"

#include "tactilepropertywatcher.h"

#include "tactileplayer.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "tactilefeedbackresolverTraces.h"

#endif

// Security policies for reading and writing to our P&S property

_LIT_SECURITY_POLICY_PASS( KTactileReadPolicy );

_LIT_SECURITY_POLICY_C1(   KTactileWritePolicy, ECapabilityWriteDeviceData );

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

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

// Consructor.

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

//

CTactileFeedbackResolver::CTactileFeedbackResolver() : 

    iFeedbackStarted( EFalse ), 

    iLastFeedback( ETouchFeedbackNone ) 

    {

    }

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

// 2nd phase costructor.

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

//

void CTactileFeedbackResolver::ConstructL()

    {

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

    InitializeCrKeysL();

    TInt hapticsUid(0);  

    TInt audioUid(0);    

    User::LeaveIfError( iRepository->Get( KTactileHapticsPlugin, hapticsUid ) );

    User::LeaveIfError( iRepository->Get( KTactileAudioPlugin, audioUid ) );

    if ( hapticsUid )

        {

        CreateHapticsPlayerL( TUid::Uid( hapticsUid ) );

        }

    if ( audioUid )

        {

        CreateAudioPlayerL( TUid::Uid( audioUid ) );

        }    

    InitializePsKeysL();

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

    }

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

// 2-phased constructor.

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

//

CTactileFeedbackResolver* CTactileFeedbackResolver::NewL()

    {

    CTactileFeedbackResolver* self = new ( ELeave ) CTactileFeedbackResolver;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor.

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

//

CTactileFeedbackResolver::~CTactileFeedbackResolver()

    {

    delete iCenRepNotifier;

    delete iRepository;

    delete iProfileRepository;

    delete iPropertyWatcher;

    delete iHapticsPlayer;

    delete iAudioPlayer;

    REComSession::FinalClose();

    }

TBool CTactileFeedbackResolver::IsHigherThanPlaying(

    TTouchLogicalFeedback aFeedback ) const

    {

    if( aFeedback == ETouchFeedbackBasicItem &&

        iLastFeedback == ETouchFeedbackSensitiveItem )

        {

        return ETrue;

        }

    return ( aFeedback == ETouchFeedbackPopUp || 

            aFeedback == ETouchFeedbackPopupOpen || 

            aFeedback == ETouchFeedbackPopupClose ||

            aFeedback == ETouchFeedbackBounceEffect ) &&

            ( iLastFeedback == ETouchFeedbackBasicButton ||

            iLastFeedback == ETouchFeedbackSensitiveButton ||

            iLastFeedback == ETouchFeedbackSensitiveItem ||

            iLastFeedback == ETouchFeedbackBasicItem ||

            iLastFeedback == ETouchFeedbackCheckbox );

    }

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

// We play feedback in case all three conditions are met:

// 

// #1 Either vibra or audio feedback is requested and globally enabled

// #2 Given feedback type is different than "None"

// #3 Player instance exists

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

//

void CTactileFeedbackResolver::PlayFeedback( 

    TTouchLogicalFeedback aFeedback,

    TBool aPlayVibra,

    TBool aPlayAudio )

    {

    // TRACE("CTactileFeedbackResolver::PlayFeedback - Begin");

    // Feedback filtering in order to prevent too many feedbacks

    // in a short time (e.g. when doing text selection).    

    TTime now;

    now.UniversalTime();

    TTimeIntervalMicroSeconds interval = 

        now.MicroSecondsFrom( iLastFeedbackTimeStamp );

    TBool willPlay = EFalse;

    if ( iMinimumInterval == TTimeIntervalMicroSeconds( 0 ) || 

         now < iLastFeedbackTimeStamp ||                       

         iMinimumInterval <= interval )

        {

        willPlay = ETrue;

        }

    else if ( IsHigherThanPlaying( aFeedback ) )

        {

        willPlay = ETrue;

        StopFeedback();

        }

    if ( willPlay )

        {

        // First store the timestamp of this feedback playing moment.

        // This really needs to be done when 

        // actually playing feedback (not when feedback was requested

        // but filtered out).

        iLastFeedbackTimeStamp = now;      

        iLastFeedback = aFeedback;

        // Force vibra- and audio feedback off if those are globally disabled

        if ( !iVibraEnabled )

            {

            aPlayVibra = EFalse;

            }

        if ( !iAudioEnabled )

            {

            aPlayAudio = EFalse;

            }

        // check silent mode, if device is in silent mode, 

        // audio feedback is not allowed.

        TInt err;

        TInt isAudioSupported;

        err = iProfileRepository->Get( KProEngSilenceMode, isAudioSupported );

        if ( KErrNone == err && 1 == isAudioSupported )

            {

            aPlayAudio = EFalse;

            }

        if ( ( aPlayVibra || aPlayAudio ) &&        // #1

               aFeedback != ETouchFeedbackNone )    // #2

            {

            OstTrace0( TACTILE_PERFORMANCE, TACTILE_RESOLVER_PLAY_FEEDBACK_1, "e_TACTILE_RESOLVER_PLAY_FEEDBACK 1");

            if ( iVibraFirst )   

                {

                if ( aPlayVibra && iHapticsPlayer )

                    {

                    iHapticsPlayer->PlayFeedback( aFeedback );    

                    }

                if ( aPlayAudio && iAudioPlayer )

                    {

                    iAudioPlayer->PlayFeedback( aFeedback );    

                    }                

                }

            else

                {

                if ( aPlayAudio && iAudioPlayer )

                    {

                    iAudioPlayer->PlayFeedback( aFeedback );    

                    }                

                if ( aPlayVibra && iHapticsPlayer )

                    {

                    iHapticsPlayer->PlayFeedback( aFeedback );    

                    }

                }

            OstTrace0( TACTILE_PERFORMANCE, TACTILE_RESOLVER_PLAY_FEEDBACK_0, "e_TACTILE_RESOLVER_PLAY_FEEDBACK 0");

            }

        }

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

    }

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

// Central Repository related initializations.

// 

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

//   

void CTactileFeedbackResolver::InitializeCrKeysL()    

    {

    if ( !iRepository )

        {

        iRepository = CRepository::NewL( KCRUidTactileFeedback );    

        }

    if ( !iProfileRepository )

        {

        iProfileRepository = CRepository::NewL( KCRUidProfileEngine );

        }

    TInt minInterval(0);

    // Read and store minimun feedback interfal

    User::LeaveIfError( iRepository->Get( KTactileFeedbackMinimumInterval, 

                                          minInterval ) );

    // Time is in milliseconds in Central Repository

    iMinimumInterval = TTimeIntervalMicroSeconds( 1000*minInterval );

    TInt internalSettings(0); 

    User::LeaveIfError( iRepository->Get( KTactileInternalSettings, 

                                          internalSettings ) );

    iVibraFirst = internalSettings & KTactileInternalSettingsVibraPlayedFirst;

    // Notifier for Central Repository changes.

    if ( !iCenRepNotifier )

        {

        iCenRepNotifier = CCenRepNotifyHandler::NewL( *this, 

                                                      *iRepository );

        iCenRepNotifier->StartListeningL();             

        }

    }

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

// P&S -related initializations have been moved here for making

// ConstructL more clear.

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

//

void CTactileFeedbackResolver::InitializePsKeysL()

    {

    TInt err = RProperty::Define( 

                KPSUidTactileFeedback,

                KTactileFeedbackEnabled,

                RProperty::EInt,

                KTactileReadPolicy,

                KTactileWritePolicy );

    if ( err != KErrNone && err != KErrAlreadyExists )

        {

        User::Leave( err );

        }

    // Enable feedback by default.

    TInt playerType(0);

    playerType |= ETouchFeedbackVibra;

    playerType |= ETouchFeedbackAudio;    

    RProperty::Set( KPSUidTactileFeedback, KTactileFeedbackEnabled, playerType );    

    // Watcher will start monitoring immediately, i.e. we don't have to

    // start it separately.

    iPropertyWatcher = CTactilePropertyWatcher::NewL(

        *this,

        KPSUidTactileFeedback,

        KTactileFeedbackEnabled,

        CActive::EPriorityStandard );

    ReadFeedbackEnabledFromPS();    

    }

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

// We only change our bookkeeping in case we succeed in reading the P&S

// property

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

//

void CTactileFeedbackResolver::ReadFeedbackEnabledFromPS()

    {

    TInt tmpVal = 0;

    TInt err = iPropertyWatcher->Get( tmpVal );

    if ( err == KErrNone )

        {

        iVibraEnabled = EFalse;

        iAudioEnabled = EFalse;

        // Check if vibra feedback is enabled (bit 0x01).

        if ( (tmpVal & 0x01) )

            {

            iVibraEnabled = ETrue;

            }

        // Check if audio feedback is enabled (bit 0x02).            

        if ( (tmpVal & 0x02) )

            {

            iAudioEnabled = ETrue;            

            }

        }

    }   

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

// From class MTactilePropertyObserver

// Called when the property for globally enabling or disabling feedback

// changes

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

//

void CTactileFeedbackResolver::PropertyChangedL( const TUid aCategory, 

                                                 const TUint aKey )

    {

    if ( aCategory == KPSUidTactileFeedback && 

         aKey == KTactileFeedbackEnabled )

        {

        ReadFeedbackEnabledFromPS();

        }

    }    

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

// Start continuous feedback.

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

//   

void CTactileFeedbackResolver::StartFeedback( TTouchContinuousFeedback aType,

                                              TInt aIntensity )

    {

    if ( iHapticsPlayer && !iFeedbackStarted && iVibraEnabled )

        {

        iHapticsPlayer->StartFeedback( aType, aIntensity );

        iFeedbackStarted = ETrue;

        }

    }

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

// Modify continuous feedback.

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

//                        

void CTactileFeedbackResolver::ModifyFeedback( TInt aIntensity )

    {

    if ( iHapticsPlayer )

        {

        iHapticsPlayer->ModifyFeedback( aIntensity );

        }    

    }

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

// Stop continuous feedback.

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

//    

void CTactileFeedbackResolver::StopFeedback()

    {

    if ( iHapticsPlayer )

        {

        iHapticsPlayer->StopFeedback();

        iFeedbackStarted = EFalse;

        }  

    }

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

// Play preview feedback.

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

//    

void CTactileFeedbackResolver::PlayPreviewFeedback( TInt aLevel,

                          TTouchLogicalFeedback aFeedback,

                          TTouchFeedbackType aType )

    {

    if ( aType & ETouchFeedbackVibra && iHapticsPlayer )

        {

        iHapticsPlayer->PlayPreviewFeedback( aLevel, aFeedback );

        }

    if ( aType & ETouchFeedbackAudio && iAudioPlayer )

        {

        iAudioPlayer->PlayPreviewFeedback( aLevel, aFeedback );

        }    

    }

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

// Start preview of continuous feedback.

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

//

void CTactileFeedbackResolver::StartPreviewFeedback( TInt aLevel,

                           TTouchContinuousFeedback aFeedback,

                           TInt aIntensity,

                           TTouchFeedbackType aType )

    {

    if ( aType & ETouchFeedbackVibra && iHapticsPlayer )

        {

        iHapticsPlayer->StartPreviewFeedback( aLevel, aFeedback, aIntensity );

        }    

    }

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

// Stop preview of continuous feedback.

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

//

void CTactileFeedbackResolver::StopPreviewFeedback()

    {

    if ( iHapticsPlayer )

        {

        iHapticsPlayer->StopPreviewFeedback();

        }        

    }

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

// Create haptics player.

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

//    

void CTactileFeedbackResolver::CreateHapticsPlayerL( TUid aHapticsUid )

    {

    RImplInfoPtrArray implArray;

    CleanupClosePushL( implArray );

    CTactilePlayer::ListImplementationsL( ETactilePlayerHaptics, implArray );

    if (!implArray.Count())

        {

        TRACE( "CTactileFeedbackResolver::ConstructL - No Haptics plugins found" );

        }

    for ( TInt i(0) ; i < implArray.Count() && !iHapticsPlayer; i++ )

        {

        // Create haptics player. 

        if ( !iHapticsPlayer &&

           ( implArray[i]->ImplementationUid() == aHapticsUid ) )

            {

            TUid pluginUid = implArray[i]->ImplementationUid();

            // delete implementation info list contents

            implArray.ResetAndDestroy();

            iHapticsPlayer = CTactilePlayer::NewL( pluginUid, *iRepository );

            }

        }

    // Make sure that implArray is reseted also if plugin wasn't found.    

    if ( !iHapticsPlayer ) 

        {

        implArray.ResetAndDestroy();

        }

    CleanupStack::PopAndDestroy( &implArray );            

    }

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

// Create audio player.

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

//        

void CTactileFeedbackResolver::CreateAudioPlayerL( TUid aAudioUid )

    {

    RImplInfoPtrArray implArray;

    CleanupClosePushL( implArray );    

    CTactilePlayer::ListImplementationsL( ETactilePlayerAudio, implArray );

    if (!implArray.Count())

        {

        TRACE( "CTactileFeedbackResolver::ConstructL - No Audio plugins found" );

        }

    for ( TInt i(0) ; i < implArray.Count() && !iAudioPlayer; i++ )

        {            

        // Create audio player.           

        if ( !iAudioPlayer &&

             ( implArray[i]->ImplementationUid() == aAudioUid ) )

            {

            TUid pluginUid = implArray[i]->ImplementationUid();

            // delete implementation info list contents

            implArray.ResetAndDestroy();     

            iAudioPlayer = CTactilePlayer::NewL( pluginUid, *iRepository );

            }                

        }

    // Make sure that implArray is reseted also if plugin wasn't found.

    if ( !iAudioPlayer ) 

        {

        implArray.ResetAndDestroy();

        }        

    CleanupStack::PopAndDestroy( &implArray );    

    }

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

// From MCenRepNotifyHandlerCallback.

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

//

void CTactileFeedbackResolver::HandleNotifyGeneric( TUint32 aId )

    {