/*

* 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:  Haptics server reservation handler implementation

*

*/

#include "hwrmhapticsreservationhandler.h"

#include "hwrmhapticstrace.h"

#include "hwrmhapticsclientserver.h"

#include "hwrmhapticsservice.h"

#include "hwrmhapticspolicy.h"

const TInt KDefaultPriority = 0;

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

// Two-phased constructor.

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

//

EXPORT_C CHWRMHapticsReservationHandler* CHWRMHapticsReservationHandler::NewL(

    const TDesC& aPolicyFilename )

    {

    COMPONENT_TRACE( ( _L( "CHWRMHapticsReservationHandler::NewL()" ) ) );

    CHWRMHapticsReservationHandler* self = 

        new ( ELeave ) CHWRMHapticsReservationHandler();

    CleanupStack::PushL( self );

    self->ConstructL( aPolicyFilename );

    CleanupStack::Pop( self );

    COMPONENT_TRACE( ( _L( "CHWRMHapticsReservationHandler::NewL - return 0x%x" ), self ) );

    return self;

    }

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

// Destructor.

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

//

CHWRMHapticsReservationHandler::~CHWRMHapticsReservationHandler()

    {

    COMPONENT_TRACE( ( _L( "CHWRMHapticsReservationHandler::~CHWRMHapticsReservationHandler()" ) ) );

    delete iPolicy;

    iPolicy = NULL;

    // delete reservations

    while ( iReservation )

        {

        TReservationData* deleteData = iReservation;

        iReservation = iReservation->iSuspendedData;

        delete deleteData;

        }

    iPriorities.Close();

    COMPONENT_TRACE( ( _L( "CHWRMHapticsReservationHandler::~CHWRMHapticsReservationHandler - return" ) ) );

    }

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

// Reserve's resource.

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

//

TBool CHWRMHapticsReservationHandler::ReserveL( 

                                    TSecureId aSid, 

                                    TBool aForceNoCCoeEnv, 

                                    CHWRMHapticsService* aServiceCallback )

    {

    COMPONENT_TRACE( ( _L( "CHWRMHapticsReservationHandler::ReserveL(0x%x, 0x%x)" ),

                       aForceNoCCoeEnv, aServiceCallback ) );

    TBool trusted( EFalse );

    TInt priority = KDefaultPriority;

    // get priority and trusted/not-trusted value

    GetPriority( aSid, trusted, priority );

    // If no CCoeEnv is forced, check that client is trusted

    if ( aForceNoCCoeEnv && !trusted )

        {

        User::Leave( KErrAccessDenied );

        }

    // keeps track whether or not the made reservation was suspended

    TBool reserveSuspended = EFalse;

    // If caller is not yet reserving this subresource, reserve it.

    if ( !AlreadyReserved( aServiceCallback ) )

        {

        // if active reservation has higher priority, reservation

        // becomes suspended

        if ( iReservation && iReservation->iPriority >= priority )

            {

            reserveSuspended = ETrue;

            }

        // Create data objects at this point so that any OOM leaves 

        // will not cause reservation state to be uncertain

        TReservationData* newData = new ( ELeave ) TReservationData();

        // Now we have done the memory allocation we need to, 

        // so we can reserve haptics with no risk of OOM errors

        // and therefore be sure that reservations array is never left in 

        // undetermined state.

        newData->iCallback = aServiceCallback;

        newData->iPriority = priority;

        if ( reserveSuspended )

            {

            // Reserve suspended, i.e. go through list until next one has lower priority

            TReservationData* priorityCheckData = iReservation->iSuspendedData;

            TReservationData* priorityPreviousData = iReservation;

            while ( priorityCheckData && 

                    priorityCheckData->iPriority <= priority )

                {

                priorityPreviousData = priorityCheckData;

                priorityCheckData = priorityCheckData->iSuspendedData;

                }

            // insert new data

            newData->iSuspendedData = priorityCheckData;

            priorityPreviousData->iSuspendedData = newData;

            // Notify callback of the reserver that it is suspended

            NotifySuspend( newData );

            }

        else 

            {

            // Reserve as active, i.e. first in list

            newData->iSuspendedData = iReservation;

            iReservation = newData;

            // Notify callback of current reserver

            NotifySuspend( newData->iSuspendedData );

            }

        }             

    COMPONENT_TRACE( ( _L( "CHWRMHapticsReservationHandler::ReserveL - return" ) ) );

    return reserveSuspended;

    }

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

// Releases reservation of a service.

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

//

TBool CHWRMHapticsReservationHandler::Release( 

                                    CHWRMHapticsService* aServiceCallback )

    {

    COMPONENT_TRACE( ( _L( "CHWRMHapticsReservationHandler::Release(0x%x)" ), aServiceCallback) );

    // find the reservation data from the list

    TReservationData* found = iReservation;

    TReservationData* prev = NULL;

    // continue searching while there are items in the list, or until 

    // the item is found

    while ( found && found->iCallback != aServiceCallback )

        {

        prev = found;

        found = found->iSuspendedData;

        }

    // remove reservation if it was found

    if ( found )

        {

        COMPONENT_TRACE( ( _L( "CHWRMHapticsReservationHandler::Release - Releasing: 0x%x, suspendedData = 0x%x" ), found, found->iSuspendedData ) );

        if ( !prev )

            {

            // reservation is the first one in the list, activate next item

            iReservation = found->iSuspendedData;

            }

        else

            {

            // reservation is in the middle of the list, reset list's links

            prev->iSuspendedData = found->iSuspendedData;

            }

        // delete released service

        delete found;

        found = NULL;

        // Reactivate first service on list

        NotifyResume( iReservation );

        }

    else

        {

        // reservation not found

        COMPONENT_TRACE( ( _L( "CHWRMHapticsReservationHandler::Release - Reservation not found, releasing nothing" ) ) );

        }

    COMPONENT_TRACE( ( _L( "CHWRMHapticsReservationHandler::Release - return" ) ) );

    return (iReservation ? ETrue : EFalse);

    }

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

// Returns whether or not haptics is reserved for some other service than

// given one.

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

//

TBool CHWRMHapticsReservationHandler::IsReserved( 

                        const CHWRMHapticsService* aServiceCallback ) const

    {

    COMPONENT_TRACE( ( _L( "CHWRMHapticsReservationHandler::IsReserved(0x%x)" ), aServiceCallback ) );

    TBool retval = EFalse;

    // Check if haptics is reserved to somebody other than caller

    if ( iReservation && iReservation->iCallback != aServiceCallback )

        {

        retval = ETrue;

        }

    COMPONENT_TRACE( ( _L( "CHWRMHapticsReservationHandler::IsReserved - return: 0x%x" ), retval ) );

    return retval;

    }

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

// Checks whether or not haptics is reserved for the given client.

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

//

TBool CHWRMHapticsReservationHandler::ActiveReservation( 

                        const CHWRMHapticsService* aServiceCallback ) const

    {

    COMPONENT_TRACE( ( _L( "CHWRMHapticsReservationHandler::ActiveReservation(0x%x)" ), aServiceCallback ) );

    TBool retval = EFalse;

    // Check if haptics is reserved for the given service

    if ( iReservation && iReservation->iCallback == aServiceCallback )

        {

        retval = ETrue;

        }

    COMPONENT_TRACE( ( _L( "CHWRMHapticsReservationHandler::ActiveReservation - return: 0x%x" ), retval ) );

    return retval;

    }

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

// Checks whether current haptics client's priority is higher than new 

// request making client's priority.

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

//

TBool CHWRMHapticsReservationHandler::ReservedPriorityHigher( 

                                                    TSecureId aSid ) const

    {

    COMPONENT_TRACE( ( _L( "CHWRMHapticsReservationHandler::ReservedPriorityHigher" ) ) );

    TBool ret = EFalse;

    if( iReservation )

        {

        // active reservation is the first reservation data

        TInt activePriority = iReservation->iPriority;

        // get priority of the calling service

        TBool trusted = EFalse;

        TInt reqPriority = KDefaultPriority;

        GetPriority( aSid, trusted, reqPriority );

        // check priority order

        if ( activePriority >= reqPriority )

            {

            ret = ETrue;

            }

        }

    COMPONENT_TRACE( ( _L( "CHWRMHapticsReservationHandler::ReservedPriorityHigher - ret %d" ), ret ) );

    return ret;

    }

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

// Sets the priority of a client (used when executing priority setting

// requested by the client using SetDeviceProperty()).

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

//

void CHWRMHapticsReservationHandler::SetPriorityL( TSecureId aSid, 

                                                   TInt aPriority )

    {

    COMPONENT_TRACE( ( _L( "CHWRMHapticsReservationHandler::SetPriorityL" ) ) );

    // do not insert new priority, if already set; just update old value

    TInt exists = EFalse;

    for ( TInt i = 0; i < iPriorities.Count() && !exists; ++i )

        {

        if ( iPriorities[i].iSid == aSid )

            {

            iPriorities[i].iPriority = aPriority;

            exists = ETrue;

            }

        }

    // if not found, insert new data

    if ( !exists )

        {

        TPriority priority( aSid, aPriority );

        iPriorities.AppendL( priority );

        }

    COMPONENT_TRACE( ( _L( "CHWRMHapticsReservationHandler::SetPriorityL - return" ) ) );

    }

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

// Removes the priority of a client.

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

//

void CHWRMHapticsReservationHandler::RemovePriority( TSecureId aSid )

    {

    COMPONENT_TRACE( ( _L( "CHWRMHapticsReservationHandler::RemovePriority" ) ) );

    TInt removed = EFalse;

    for ( TInt i = 0; i < iPriorities.Count() && !removed; ++i )

        {

        if ( iPriorities[i].iSid == aSid )

            {

            iPriorities.Remove( i );

            removed = ETrue;

            }

        }

    COMPONENT_TRACE( ( _L( "CHWRMHapticsReservationHandler::RemovePriority - return" ) ) );

    }

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

// Fetches the priority of a client identified using the given secure id.

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

//

void CHWRMHapticsReservationHandler::GetPriority( TSecureId aSid, 

                                               TBool& aTrusted, TInt& aPriority ) const

    {

    COMPONENT_TRACE( ( _L( "CHWRMHapticsReservationHandler::GetPriority" ) ) );

    // initialize return value with the default priority

    TInt priority = KDefaultPriority;

    // search from the priority array

    TInt found = EFalse;

    for ( TInt i = 0; i < iPriorities.Count() && !found; ++i )

        {

        if ( iPriorities[i].iSid == aSid )

            {

            priority = iPriorities[i].iPriority;

            found = ETrue;

            }

        }

    TInt policyPriority;

    // search priority from the policy file data

    iPolicy->GetPriority( aSid, aTrusted, policyPriority );

    // set priority from policy file, if not found from priority array

    // and found from the policy file (i.e. trusted client)

    if ( !found && aTrusted )

        {

        priority = policyPriority;

        }

    aPriority = priority;

    COMPONENT_TRACE( ( _L( "CHWRMHapticsReservationHandler::GetPriority - return %d" ), priority ) );

    }

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

// C++ constructor

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

//

CHWRMHapticsReservationHandler::CHWRMHapticsReservationHandler()

    {

    COMPONENT_TRACE( ( _L( "CHWRMHapticsReservationHandler::CHWRMHapticsReservationHandler()" ) ) );

    }

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

// Symbian 2nd phase constructor.

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

//

void CHWRMHapticsReservationHandler::ConstructL( 

                                            const TDesC& aPolicyFilename )

    {

    COMPONENT_TRACE( ( _L( "CHWRMHapticsReservationHandler::ConstructL()" ) ) );

    // Initialize policy object

    iPolicy = CHWRMHapticsPolicy::NewL( aPolicyFilename );

    COMPONENT_TRACE( ( _L( "CHWRMHapticsReservationHandler::ConstructL - return" ) ) );

    }

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

// Returns whether or not a reservation exists for the given service.

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

//

TBool CHWRMHapticsReservationHandler::AlreadyReserved( 

                        const CHWRMHapticsService* aService ) const

    {

    TBool reserved = EFalse;

    // go through the reservations

    TReservationData* reservationData = iReservation;

    while ( reservationData && !reserved )

        {

        if ( reservationData->iCallback == aService )

            {

            // reservation found for the service

            reserved = ETrue;

            }

        reservationData = reservationData->iSuspendedData;

        }

    return reserved;

    }

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

// Notifies callback that its reservations has been suspended.

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

//

void CHWRMHapticsReservationHandler::NotifySuspend( 

                                            TReservationData* aData ) const

    {

    if ( aData && aData->iCallback )

        {

        aData->iCallback->SuspendResource();

        }

    }

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

// Notifies callback that its reservations has been resumed.

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

//

void CHWRMHapticsReservationHandler::NotifyResume( 

                                            TReservationData* aData ) const

    {

    if ( aData && aData->iCallback )

        {

        aData->iCallback->ResumeResource();

        }

    }

//  End of File