// Copyright (c) 2006-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:

//

// INCLUDE FILES

#include "HWRMServer.h"

#include "HWRMVibraClientServer.h"

#include "HWRMService.h"

#include "HWRMVibraService.h"

#include "HWRMVibraCommands.h"

#include "HWRMPluginHandler.h"

#include "HWRMtrace.h"

#include "HWRMVibraCommonData.h"

#include "HWRMVibra.h"

#include "HWRMReservationHandler.h"

#include "HWRMPrivateCRKeys.h"

#include "HWRMDomainPSKeys.h"

#include "HWRMPrivatePSKeys.h"

#include "HWRMVibraCommonService.h"

// EXTERNAL DATA STRUCTURES

// None

// EXTERNAL FUNCTION PROTOTYPES  

// None

// CONSTANTS

// None

// MACROS

// None

// LOCAL CONSTANTS AND MACROS

_LIT( KPanicCategory, "HWRMVibraService" );

const TInt KHWRMVibraMaxDurationInMicroseconds = KHWRMVibraMaxDuration * 1000;

const TInt KHWRMVibraTimerID = KMaxTInt;

const TInt KHWRMVibraNoTimer = KMinTInt;

// MODULE DATA STRUCTURES

// None

// LOCAL FUNCTION PROTOTYPES

// None

// FORWARD DECLARATIONS

// None

// ============================= LOCAL FUNCTIONS ===============================

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

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

// CHWRMVibraService::CHWRMVibraService

// C++ constructor

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

//

CHWRMVibraService::CHWRMVibraService(CHWRMVibraCommonService& aCommonService,

                                     CHWRMVibraCommonData& aVibraCommonData,

                                     TBool aPrivilegedClient)

    : iVibraCommonData(aVibraCommonData),

      iPrivilegedClient(aPrivilegedClient),

      iStateSetAfterReservation(EFalse),

      iCommonService(aCommonService),

      iSid(0),

      iActiveTimerId(KHWRMVibraTimerID)

    {

    COMPONENT_TRACE1(_L( "HWRM Server - CHWRMVibraService::CHWRMVibraService()" ) );

    COMPONENT_TRACE1(_L( "HWRM Server - CHWRMVibraService::CHWRMVibraService - return" ) );

    }

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

// CHWRMVibraService::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CHWRMVibraService::ConstructL(CHWRMPluginHandler* aPluginHandler,

                                   CHWRMReservationHandler* aReservationHandler)

    {    

    COMPONENT_TRACE2(_L( "HWRM Server - CHWRMVibraService::ConstructL(0x%x)" ), aPluginHandler );

    BaseConstructL(aPluginHandler, aReservationHandler);

    // Create vibra timer with special identifier.

    iVibraTimer = CHWRMGenericTimer::NewL(*this, iVibraCommonData.MaximumOnTime(), KHWRMVibraTimerID);

    COMPONENT_TRACE1(_L( "HWRM Server - CHWRMVibraService::ConstructL - return " ) );

    }

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

// CHWRMVibraService::NewL

// Two-phased constructor.

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

//

CHWRMVibraService* CHWRMVibraService::NewL(CHWRMPluginHandler* aPluginHandler,

                                           CHWRMReservationHandler* aReservationHandler,

                                           CHWRMVibraCommonService& aCommonService,

                                           CHWRMVibraCommonData& aVibraCommonData,

                                           TBool aPrivilegedClient)

    {

    COMPONENT_TRACE3(_L( "HWRM Server - CHWRMVibraService::NewL(0x%x, aPrivilegedClient: 0x%x)" ), aPluginHandler, aPrivilegedClient );

    CHWRMVibraService* self = new( ELeave ) CHWRMVibraService(aCommonService, aVibraCommonData, aPrivilegedClient);

    CleanupStack::PushL( self );

    self->ConstructL(aPluginHandler, aReservationHandler);

    CleanupStack::Pop();

    COMPONENT_TRACE2(_L( "HWRM Server - CHWRMVibraService::NewL - return 0x%x" ), self );

    return self;

    }

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

// Destructor

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

//

CHWRMVibraService::~CHWRMVibraService()

    {

    COMPONENT_TRACE1(_L( "HWRM Server - CHWRMVibraService::~CHWRMVibraService()" ) );

    // Cleanup vibra just in case regular cleanup failed

    CleanupVibra();    

    // Delete timer

    if (iVibraTimer)

        {

        iVibraTimer->Cancel();

        delete iVibraTimer;

        }

    ReleasePulseData();

    // Base class cleanup

    BaseDestruct();

    COMPONENT_TRACE1(_L( "HWRM Server - CHWRMVibraService::~CHWRMVibraService - return" ) );

    }

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

// CHWRMVibraService::ReleasePulseData

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

//

void CHWRMVibraService::ReleasePulseData()

    {

    COMPONENT_TRACE2(_L( "HWRM Server - CHWRMVibraService::ReleasePulseData(), count %d" ), iPulseData.Count() );

    iPulseData.ResetAndDestroy();

    COMPONENT_TRACE1(_L( "HWRM Server - CHWRMVibraService::ReleasePulseData - return" ) );

    }

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

// CHWRMVibraService::CleanupVibra

// Cleans up vibra. 

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

//

void CHWRMVibraService::CleanupVibra()

    {    

    if ( !iCleanupDone )

        {        

        COMPONENT_TRACE1(_L( "HWRM Server - CHWRMVibraService::CleanupVibra()" ) );

        TInt unreserved(0x0);

        // If still reserved, release

        if ( iReserved )

            {

            unreserved = iReservationHandler->Release(this, KHWRMAllSubResources);	

            iReserved = EFalse;

            iSuspended = EFalse;

            }

        else

            {

            unreserved = iReservationHandler->GetUnreservedTargets();

            }

        COMPONENT_TRACE3(_L("HWRM Server - CHWRMVibraService::CleanupVibra - Vibra status: %d, reservation status: %d"), iLastStatus, unreserved );

        // If this session has set vibra to vibrate and vibra is unreserved, stop it.

        if ( unreserved && iLastStatus == CHWRMVibra::EVibraStatusOn )

            {

            RMessage2 dummy; // Use dummy to avoid adaptation returned error messages failing cleanup            

            TRAPD(err, StopVibraL(dummy, EFalse, ETrue));

            if ( err != KErrNone )

                {

                COMPONENT_TRACE2(_L("HWRM Server - CHWRMVibraService::CleanupVibra - Stopping vibra failed: %d"), err );

                }

            else 

                {

                // Since there will be no ProcessResponse for this one, publish the status now

                iVibraCommonData.PublishVibraStatus(CHWRMVibra::EVibraStatusStopped, iPrivilegedClient);	    

                }

            }

        // Make sure client requests get cleared if not via StopVibraL

        if( iCommonService.HasData( this ) )

            {

            iCommonService.ResetClientData( this );

            }

        iCleanupDone = ETrue;

        COMPONENT_TRACE1(_L( "HWRM Server - CHWRMVibraService::CleanupVibra - return" ) );    

        }

    else

        {

        COMPONENT_TRACE1(_L( "HWRM Server - CHWRMVibraService::CleanupVibra - Already cleaned up" ) );    

        }

    }

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

// CHWRMVibraService::ForceVibraStop

// Stops vibra. 

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

//

void CHWRMVibraService::ForceVibraStop()

    {

    COMPONENT_TRACE1(_L( "HWRM Server - CHWRMVibraService::ForceVibraStop()" ) );

    RMessage2 dummy;

    TRAP_IGNORE(StopVibraL(dummy, ETrue));

    COMPONENT_TRACE1(_L( "HWRM Server - CHWRMVibraService::ForceVibraStop - return" ) );

    }

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

// CHWRMVibraService::ExecuteMessageL

// Handles Vibra requests. 

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

//

TBool CHWRMVibraService::ExecuteMessageL( const RMessage2& aMessage )

    {

    COMPONENT_TRACE2(_L( "HWRM Server - CHWRMVibraService::ExecuteMessageL(0x%x)" ), aMessage.Function() );

    __ASSERT_ALWAYS(iPluginHandler, User::Panic(KPanicCategory, EPanicBadHandle));

    __ASSERT_ALWAYS(iReservationHandler, User::Panic(KPanicCategory, EPanicBadHandle));

    if ( aMessage.IsNull() )

        {

        User::Leave(KErrBadHandle);

        }

    // All messages are by default asynchronous because of the nature of the plugin API

    TBool completeMessage(EFalse);

    TInt function( aMessage.Function() );

	// Retrieve client sid

    iSid = aMessage.SecureId();

    switch ( function )

        {

    	case EHWRMStartVibraDefaultIntensity:

    	    {

            COMPONENT_TRACE1(_L("HWRM Server - CHWRMVibraService::ExecuteMessageL - EHWRMStartVibraDefaultIntensity") );

            StartVibraL( aMessage.Int0() * 1000, KUseDefaultIntensity, aMessage);   

    		break;

    	    }

    	case EHWRMStartVibra:

    	    {

            COMPONENT_TRACE1(_L("HWRM Server - CHWRMVibraService::ExecuteMessageL - EHWRMStartVibra") );

            StartVibraL(aMessage.Int0() * 1000, aMessage.Int1(), aMessage);            

    		break;

    	    }

    	case EHWRMPulseVibraDefault:

    	case EHWRMPulseVibraDefaultIntensity:

    	case EHWRMPulseVibra:

    	    {

            // First of all check whether pulse request allowed by this client.

            if ( !iCommonService.VibraPulseAllowed( aMessage.SecureId() ) )

                {

                User::Leave(KErrAccessDenied);

                }

            TInt duration( iVibraCommonData.FeedbackDefaultDuration() * 1000 );

            TInt intensity( iVibraCommonData.FeedbackDefaultIntensity() );

            if( function == EHWRMPulseVibraDefault )

                {

                COMPONENT_TRACE1(_L("HWRM Server - CHWRMVibraService::ExecuteMessageL - EHWRMPulseVibraDefault") );

                }

            else if( function == EHWRMPulseVibraDefaultIntensity )

                {

                COMPONENT_TRACE1(_L("HWRM Server - CHWRMVibraService::ExecuteMessageL - EHWRMPulseVibraDefaultIntensity") );

                duration = aMessage.Int0() * 1000;

                }

            else

                {

                COMPONENT_TRACE1(_L("HWRM Server - CHWRMVibraService::ExecuteMessageL - EHWRMPulseVibra") );

                duration = aMessage.Int0() * 1000;

                intensity = aMessage.Int1();

                }

            COMPONENT_TRACE2(_L("HWRM Server - CHWRMVibraService::ExecuteMessageL - pulse supported %d"), 

                iVibraCommonData.FeedbackPulseSupported() );

            // If there is active reservation and vibration ongoing by a higher priority client, 

            // pulse request is not allowed. In all other circumstances either pulse or start 

            // command is sent to plugin.

            if ( iReservationHandler->IsReserved(this, KHWRMAllSubResources) &&

                 iCommonService.ExecutingPriorityHigher( aMessage.SecureId() ) )

                {

                User::Leave(KErrInUse);

                }

            if( iVibraCommonData.FeedbackPulseSupported() )

                {

                // It is plugin or underlying software responsibility to generate pulse start/stop

                // and continue ongoing vibration if such exists.

                PulseVibraL( duration, intensity, aMessage);

                }

            else

                {

                // Request another vibration by lefting current timer if such exist intact

                // and creating new timer for this pulse request.

                StartVibraL( duration, intensity, aMessage, EFalse, ETrue);

                }

            break;    

    	    }

    	case EHWRMStopVibra:

    	    {

            COMPONENT_TRACE1(_L("HWRM Server - CHWRMVibraService::ExecuteMessageL - EHWRMStopVibra") );

            StopVibraL(aMessage);            

    		break;

    	    }

    	case EHWRMReserveVibra:

    	    {

            COMPONENT_TRACE1(_L("HWRM Server - CHWRMVibraService::ExecuteMessageL - EHWRMReserveVibra") );

            // Reserve whole vibra. If returned mask is non-zero, reservation was done in suspended mode.

            iSuspended = (iReservationHandler->ReserveL(aMessage, aMessage.Int1(), this, KHWRMAllSubResources));	

            iReserved = ETrue;           

            iStateSetAfterReservation = EFalse;    

            // Restore previously stored state if restore was specified.

            // Errors are trapped as reservation itself was successful.

            if ( aMessage.Int0() )

                {

                TInt err(KErrNone);

                RMessage2 dummy; // Use dummy to avoid adaptation returned error messages failing reservation.

                if ( iFrozenStatus == CHWRMVibra::EVibraStatusOn )

                    {

                    TRAP(err, StartVibraL(iFrozenTime, iFrozenIntensity, dummy));

                    }

                else

                    {

                    TRAP(err, StopVibraL(dummy));

                    }

                }

            completeMessage = ETrue; // Complete needed, as dummy used.

    		break;

    	    }

    	case EHWRMReleaseVibra:

    	    {

            COMPONENT_TRACE1(_L("HWRM Server - CHWRMVibraService::ExecuteMessageL - EHWRMReleaseVibra") );

			// If a "Leave" is introduced, consideration must be given to the corresponding

			// client side side code which requested this action. In particular, ensure that

			// the client-side caller doesn't set its "iReserved" flag to false without 

			// checking the result of the Release command.

            // Release whole vibra. 

            TInt unreserved = iReservationHandler->Release(this, KHWRMAllSubResources);	

            iReserved = EFalse;

            // Clear suspended flag

            iSuspended = EFalse;

            // Freeze state

            iFrozenTime = iVibraTimer->Freeze(); 

            iFrozenStatus = iLastStatus;

            iFrozenIntensity = iLastIntensity;

            // Restore base state if no more reservations for vibra.

            // Errors are trapped as release itself was successful.

            if ( unreserved )

                {

                RMessage2 dummy; // Use dummy to avoid adaptation returned error messages failing release.

                TRAP_IGNORE(StopVibraL(dummy));

                }

            completeMessage = ETrue; // Complete needed, as dummy used.

    		break;

    	    }

        case EHWRMCleanupVibra:

            {

            COMPONENT_TRACE1(_L("HWRM Server - CHWRMVibraService::ExecuteMessageL - EHWRMCleanupVibra") );

            CleanupVibra();

            completeMessage = ETrue; // Complete needed, as dummy used in CleanupVibra.

    		break;

    	    }

        // Cannot identify the message, panic the client

        default:

            {

            CHWRMServer::PanicClient(aMessage, EPanicIllegalFunction);

            break;

            }

        }

    COMPONENT_TRACE2(_L( "HWRM Server - CHWRMVibraService::ExecuteMessageL - return 0x%x" ), completeMessage );

    return completeMessage;

   }

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

// CHWRMVibraService::StartVibraL

// Starts vibra for duration with specified intensity.

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

//

void CHWRMVibraService::StartVibraL(const TTimeIntervalMicroSeconds32& aDuration, 

                                    TInt aIntensity, 

                                    const RMessage2& aMessage,

	                                TBool aSetTimer,

                                    TBool aPulse)

	{

    COMPONENT_TRACE5(_L( "HWRM Server - CHWRMVibraService::StartVibraL(%d, %d, %d, %d)" ),

    aDuration.Int(), aIntensity, aSetTimer, aPulse );

    __ASSERT_ALWAYS(iPluginHandler, User::Panic(KPanicCategory, EPanicBadHandle));

    // Duration must not be negative.

    if ( aDuration.Int() < 0 || aDuration.Int() > KHWRMVibraMaxDurationInMicroseconds )

        {

        User::Leave(KErrArgument);

        }

    // Check vibra/feedback profile settings if not privileged client.

    // If not pulse request, vibra must be on. If pulse request, feedback must be on.

    if ( !iPrivilegedClient && 

        ( ( !aPulse && (iVibraCommonData.VibraState() != CHWRMVibra::EVibraModeON ) ) ||

          ( aPulse && (iVibraCommonData.VibraFeedbackState() != CHWRMVibra::EVibraFeedbackModeON) ) ) )        

    	{

        // Stop vibra if it needs shutdown.

        if ( iLastStatus == CHWRMVibra::EVibraStatusOn )

            {

            StopVibraL(aMessage);

            }

        User::Leave(KErrAccessDenied);

        }

    // Check if vibra is cooling off or feedback should be prevented

    if ( iVibraCommonData.VibraLocked() || (aPulse && VibraPulseBlocked()) )

        {

        User::Leave(KErrLocked);

        }

	// Check if vibra is blocked (aPulse means no feedback request)

    if ( !aPulse &&

         iVibraCommonData.VibraBlocked() && 

         iVibraCommonData.VibraBlocked( KHWRMInternalSettingsChargerBlockVibra ) )

        {

        User::Leave(KErrLocked);

        }

    // Check intensity validity

    if ( aIntensity != KUseDefaultIntensity && (aIntensity < KHWRMVibraMinIntensity || aIntensity > KHWRMVibraMaxIntensity) )

        {

        User::Leave(KErrArgument);

        }

    // Check intensity validity for pulse requests

    if ( aPulse && (aIntensity < KHWRMVibraMinPulseIntensity || aIntensity > KHWRMVibraMaxIntensity) )

        {

        User::Leave(KErrArgument);

        }

    // Call plugins

    if ( aIntensity == 0 )

        {

        // Stop vibra, if intensity is zero

        StopVibraL(aMessage);

        }

    else

        {

        // Start timers, if so specified

        // This is because when restoring last state, existing timer should be left intact.

        // Vibra timer is left intact also if pulse requested because new timer is setup.

        if ( aSetTimer && !aPulse )

            {

            iVibraTimer->Set(aDuration);

            iActiveTimerId = KHWRMVibraTimerID;

            }

        if ( aPulse )

            {

            // Create new timer with ascending identifier.

            TInt count( iPulseData.Count() );

            CHWRMGenericTimer* timer = 

                CHWRMGenericTimer::NewL(*this, iVibraCommonData.MaximumOnTime(), count );                                

            iActiveTimerId = count;

            CPulseData* pulseData = CPulseData::NewL(*timer, iLastIntensity, aIntensity, iActiveTimerId );

            CleanupStack::PushL( pulseData );

            iPulseData.AppendL( pulseData );

            CleanupStack::Pop( pulseData );