/*

* 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:  Implementation of haptics client.

*

*/

#include <hwrmhapticspacketizer.h>

#include <hwrmhapticseffectdatagetter.h>

#include "hwrmhapticsimpl.h"

#include "hwrmhapticstrace.h"

#include "hwrmhapticssession.h" // common SendReceive

#include "hwrmhapticsclientserver.h"  // Cmd Ids

#include "hwrmhapticsivtdatacache.h"

#include "hwrmhapticsstatusobserver.h"

#include "hwrmhapticsclientserver.h"

#if defined(_DEBUG)

_LIT( KPanic, "HWRMHapticsClient" );

#endif

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

// C++ constructor

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

//

CHWRMHapticsImpl::CHWRMHapticsImpl()

    : iDeviceHandle( 0 ), iOpenedActuator( EHWRMLogicalActuatorLast ),

      iEffectHandlePckg( 0 )

    {

    COMPONENT_TRACE( ( _L( "CHWRMHapticsImpl::CHWRMHapticsImpl()" ) ) );

    }

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

// Symbian 2nd phase constructor.

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

//

void CHWRMHapticsImpl::ConstructL( 

    MHWRMHapticsObserver* aHapticsCallback, 

    MHWRMHapticsActuatorObserver* aActuatorCallback )

    {

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

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

    FinalizeL( aHapticsCallback, aActuatorCallback );

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

    }

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

// Asynchronous construction.

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

//

void CHWRMHapticsImpl::ConstructL(

    MHWRMHapticsObserver* aHapticsCallback,

    MHWRMHapticsActuatorObserver* aActuatorCallback,

    TRequestStatus& aStatus )

    {

    COMPONENT_TRACE( ( _L( "CHWRMHapticsImpl::ConstructL() - ASYNC" ) ) );

    iClient.Connect( aStatus );

    FinalizeL( aHapticsCallback, aActuatorCallback );

    COMPONENT_TRACE( ( _L( "CHWRMHapticsImpl::ConstructL() - ASYNC - return" ) ) );

    }

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

// Destructor

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

//

CHWRMHapticsImpl::~CHWRMHapticsImpl()

    {

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

    if( iEffectDataGetter )

        {

        delete iEffectDataGetter;

        iEffectDataGetter = NULL;

        } 

    if( iPacketizer )

        {

        delete iPacketizer;

        iPacketizer = NULL;

        } 

    if ( iIVTDataCache )

        {

        delete iIVTDataCache;

        iIVTDataCache = NULL;

        }

    iReqData.Close();

    // Inform session that we are cleaning up now. Trace errors.

    if ( iClient.Handle() )

        {

        TInt err = iClient.ExecuteOperation( EHWRMHapticsCleanup );

        COMPONENT_TRACE( ( _L( "CHWRMHapticsImpl::~CHWRMHapticsImpl - Cleanup error code: %d" ), err ) );

        }

    // destroy observer after cleanup command, since it may receive

    // a response from the server during cleanup command execution

    if ( iStatusObserver )

        {

        delete iStatusObserver; // will also cancel active object

        iStatusObserver = NULL;

        }

    iClient.Close();

    REComSession::FinalClose();

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

    }

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

// Opens an actuator using the given logical actuator type.

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

//

void CHWRMHapticsImpl::OpenActuatorL( THWRMLogicalActuators aActuator )

    {

    API_TRACE( ( _L( "e_HWRMHAPTICS_CLIENT_OPENACTUATORL 1" ) ) );

    API_TRACE( ( _L( "CHWRMHapticsImpl::OpenActuatorL() - aActuator(%d)" ), aActuator ) );

    // check that aActuator contains one of enumeration value

    TBool validActuator = EFalse;

    for ( TInt n = EHWRMLogicalActuatorAny; n < EHWRMLogicalActuatorLast && !validActuator; n <<= 1 )

        {

        if ( aActuator == n )

            {

            validActuator = ETrue;

            }

        }

    if ( !validActuator )

        {

        User::Leave( KErrArgument );

        }

    // leave if some actuator is already opened

    if ( iOpenedActuator != EHWRMLogicalActuatorLast )

        {

        if ( aActuator == iOpenedActuator )

            {

            User::Leave( KErrAlreadyExists );

            }

        else

            {

            User::Leave( KErrInUse );

            }

        }

    if( iPacketizer )

        {

        delete iPacketizer;

        iPacketizer = NULL;

        }

    // create the packetizer instance

    iPacketizer = CHWRMHapticsPacketizer::NewL( aActuator );

    // get request data for opening an actuator

    iReqData.Close();

    User::LeaveIfError( iPacketizer->EncOpenDeviceReq( aActuator, iReqData ) );

    // initialize device handle before command execution

    iDeviceHandle = 0;

    // device handle is out-param to command

    TPckg<TInt> deviceHandlePckg( iDeviceHandle );

    User::LeaveIfError( iClient.ExecuteOperation( 

                    EHWRMHapticsOpenActuator, 

                    TIpcArgs( &iReqData, &deviceHandlePckg, aActuator ) ) );

    // opened actuator successfully, store the actuator type

    iOpenedActuator = aActuator;

    API_TRACE( _L( "CHWRMHapticsImpl::OpenActuatorL() - return" ) );

    API_TRACE( ( _L( "e_HWRMHAPTICS_CLIENT_OPENACTUATORL 0" ) ) );

    }

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

// Fetches the supported logical actuator types.

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

//

TInt CHWRMHapticsImpl::SupportedActuators( TUint32& aActuators )

    {

    API_TRACE( ( _L( "CHWRMHapticsImpl::SupportedActuators() - aActuators(%d)" ), aActuators ) );

    // data package, which should include the fetched data on return

    TPckg<TUint32> actuatorInfoPckg( aActuators );

    // send command to server

    TInt err = iClient.ExecuteOperation( EHWRMHapticsSuppActuators,

                                         TIpcArgs( &actuatorInfoPckg ) );

    API_TRACE( ( _L( "CHWRMHapticsImpl::iSupportedActuators - %d" ), aActuators ) );

    API_TRACE( ( _L( "CHWRMHapticsImpl::SupportedActuators() - return %d" ), err ) );

    return err;

    }

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

// Reserves haptics feature exclusively for this client.

// This is a convenience frontend to the below ReserveHapticsL

// with TBool argument overload.

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

//

void CHWRMHapticsImpl::ReserveHapticsL()

    {

    ReserveHapticsL( EFalse );

    }

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

// Reserves haptics feature exclusively for this client.

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

//

void CHWRMHapticsImpl::ReserveHapticsL( TBool aForceNoCCoeEnv )

    {

    API_TRACE( ( _L( "CHWRMHapticsImpl::ReserveHapticsL(0x%x)" ), aForceNoCCoeEnv ) );

    // We have not used CONE solution here because it is on middleware

    // layer. While hwrmhaptics is on OS layer.  We shall find OS layer

    // replacement for observing foreground/background events.

    /* 

    if ( !aForceNoCCoeEnv )

        {

        // Check that CCoeEnv exists

        CCoeEnv* env = CCoeEnv::Static();

        if ( env )

            {

            // Check that we are on foreground (i.e. we have keyboard focus.)

            // There can be windows on top of our application that 

            // have explicitly disabled keyboard focus,

            // but then again the foreground/background observer will not 

            // kick in in those cases either.

            // -> We can use focus to determine foreground status here.

            if ( env->WsSession().GetFocusWindowGroup() != 

                 env->RootWin().Identifier() )

                {

                COMPONENT_TRACE( ( _L( "CHWRMHapticsImpl::ReserveHapticsL - Application not focused, reserve denied." ) ) );

                User::Leave( KErrNotReady );

                }

            }

        else

            {

            COMPONENT_TRACE( ( _L( "CHWRMHapticsImpl::ReserveHapticsL - No CCoeEnv available" ) ) );

            User::Leave( KErrBadHandle );

            }

        }

    */

    // Do the actual reservation

    User::LeaveIfError( DoReserveHaptics( aForceNoCCoeEnv ) );

    API_TRACE( ( _L( "CHWRMHapticsImpl::ReserveHapticsL - return" ) ) );

    }

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

// Releases haptics feature if it was previously reserved for this client.

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

//

void CHWRMHapticsImpl::ReleaseHaptics()

    {

    API_TRACE( ( _L( "CHWRMHapticsImpl::ReleaseHaptics()" ) ) );

    DoReleaseHaptics();

    iAutoReserve = EFalse;

    API_TRACE( ( _L( "CHWRMHapticsImpl::ReleaseHaptics - return" ) ) );

    }

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

// Returns the current haptics status.

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

//

MHWRMHapticsObserver::THWRMHapticsStatus 

CHWRMHapticsImpl::HapticsStatus() const

    {

    API_TRACE( ( _L( "CHWRMHapticsImpl::HapticsStatus()" )) );

    MHWRMHapticsObserver::THWRMHapticsStatus status = 

        MHWRMHapticsObserver::EHWRMHapticsStatusAvailable;

    if ( iStatusObserver )

        {

        // ask the current status from the observer

        status = iStatusObserver->CurrentStatus();

        }

    else

        {

        TPckg<MHWRMHapticsObserver::THWRMHapticsStatus> statusPckg( status );

        // no observer available, request status from the server

        iClient.ExecuteOperation( EHWRMHapticsGetStatus,

                                  TIpcArgs( &statusPckg ) );

        }

    API_TRACE( ( _L( "CHWRMHapticsImpl::HapticsStatus - return 0x%x" ), status ) );

    return status;

    }

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

// SetDeviceProperty() - TInt overload for aDevicePropertyValue parameter

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

//

TInt CHWRMHapticsImpl::SetDeviceProperty( TInt aDevicePropertyType, 

                                          TInt aDevicePropertyValue )

    {

    __ASSERT_DEBUG( iPacketizer, User::Panic( KPanic, EPanicNotReady ) );

    if ( !iPacketizer )

        {

        return EPanicNotReady;

        }

    API_TRACE( ( _L( "CHWRMHapticsImpl::SetDeviceProperty() - TInt overloaded - aDevicePropertyType(%d), aDevicePropertyValue(%d)" ), aDevicePropertyType, aDevicePropertyValue ) );

    TInt err( KErrNone );

    switch ( aDevicePropertyType )

        {

        case CHWRMHaptics::EHWRMHapticsPriority:

            if ( aDevicePropertyValue < KHWRMHapticsMinDevicePriority ||

                 aDevicePropertyValue > KHWRMHapticsMaxDevicePriority )

                {

                API_TRACE( ( _L( "CHWRMHapticsImpl::SetDeviceProperty() - argument is not in range (EHWRMHapticsPriority)" ) ) );

                err = KErrArgument;

                }

            break;    

        case CHWRMHaptics::EHWRMHapticsDisableEffects:

            // any value is accepted

            break;

        case CHWRMHaptics::EHWRMHapticsStrength: // flow through

        case CHWRMHaptics::EHWRMHapticsMasterStrength:

            if ( aDevicePropertyValue < KHWRMHapticsMinStrength || 

                 aDevicePropertyValue > KHWRMHapticsMaxStrength )

                {

                API_TRACE( ( _L( "CHWRMHapticsImpl::SetDeviceProperty() - argument is not in range (EHWRMHaptics(Master)Strength)" ) ) );

                err = KErrArgument;

                }

            break;    

        default:             

            API_TRACE( ( _L( "CHWRMHapticsImpl::SetDeviceProperty() - invalid property type" ) ) );

            err = KErrArgument;

        }

    iReqData.Close(); 

    // encode request package

    if ( KErrNone == err )

        {

        if ( aDevicePropertyType == CHWRMHaptics::EHWRMHapticsDisableEffects )

            {

            err = iPacketizer->EncSetDevicePropertyBoolReq( 

                    iDeviceHandle, aDevicePropertyValue,

                    aDevicePropertyType, iReqData );

            }

        else

            {

            err = iPacketizer->EncSetDevicePropertyIntReq( 

                    iDeviceHandle, aDevicePropertyValue,

                    aDevicePropertyType, iReqData );

            }

        // send command to haptics server

        if ( KErrNone == err )

            {

            err = iClient.ExecuteOperation( EHWRMHaptics, 

                                            TIpcArgs( &iReqData ) );

            }

        }

    API_TRACE( ( _L( "CHWRMHapticsImpl::SetDeviceProperty() - return %d" ), err ) );    

    return err;

    }

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

// SetDeviceProperty() - TDesC8 overload for aDevicePropertyValue parameter

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

//

TInt CHWRMHapticsImpl::SetDeviceProperty( TInt aDevicePropertyType, 

                                          const TDesC8& aDevicePropertyValue )

    {

    __ASSERT_DEBUG( iPacketizer, User::Panic( KPanic, EPanicNotReady ) );

    if ( !iPacketizer )

        {

        return EPanicNotReady;

        }

    API_TRACE( ( _L( "CHWRMHapticsImpl::SetDeviceProperty() - const TDesC8 overloaded - aDevicePropertyType(%d), aDevicePropertyValue( 0x%x)" ), aDevicePropertyType, &aDevicePropertyValue ) );

    TInt err( KErrNone );

    // check property type, only license key setting supported (for

    // string value type properties)

    if( CHWRMHaptics::EHWRMHapticsLicensekey != aDevicePropertyType )

        {

        API_TRACE( ( _L( "CHWRMHapticsImpl::SetDeviceProperty() - invalid property type" ) ) );

        err = KErrArgument;

        }

    if ( KErrNone == err )

        {

        // encode request package

        iReqData.Close(); 

        err = iPacketizer->EncSetDevicePropertyStringReq(

                                    iDeviceHandle,

                                    aDevicePropertyValue,

                                    aDevicePropertyType,

                                    iReqData );

        // send command to haptics server

        if ( KErrNone == err )

            {

            if( aDevicePropertyType == EHWRMHapticsLicensekey )

                {

                err = iClient.ExecuteOperation( 

                       EHWRMHapticsSetLicenseProp, 

                       TIpcArgs( &iReqData, aDevicePropertyValue.Length() ) );

                }

            else

                {

                err = iClient.ExecuteOperation( EHWRMHaptics,  

                                                TIpcArgs( &iReqData ) );

                }

            }

        }

    API_TRACE( ( _L( "CHWRMHapticsImpl::SetDeviceProperty() - const TDesC8 overloaded - return %d" ), err ) );

    return err;

    }

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

// GetDeviceProperty() - TInt overload for aDevicePropertyValue parameter

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

//

TInt CHWRMHapticsImpl::GetDeviceProperty( TInt aDevicePropertyType, 

                                          TInt& aDevicePropertyValue )

    {

    __ASSERT_DEBUG( iPacketizer, User::Panic( KPanic, EPanicNotReady ) );

    if ( !iPacketizer )

        {

        return EPanicNotReady;

        }

    API_TRACE( ( _L( "CHWRMHapticsImpl::GetDeviceProperty() - TInt overloaded - aDevicePropertyType(%d), aDevicePropertyValue(%d)" ), aDevicePropertyType, aDevicePropertyValue ) );

    TInt err( KErrNone );

    iReqData.Close();

    if ( aDevicePropertyType == CHWRMHaptics::EHWRMHapticsDisableEffects )

        {

        err = iPacketizer->EncGetDevicePropertyBoolReq( 

                   iDeviceHandle, aDevicePropertyType, iReqData );

        }

    else

        {

        err = iPacketizer->EncGetDevicePropertyIntReq( 

                   iDeviceHandle, aDevicePropertyType, iReqData );

        }    

    if ( KErrNone == err )

        {

        TPckg<TInt> devicePropertyValuePckg( aDevicePropertyValue );

        err = iClient.ExecuteOperation( 

            EHWRMHaptics, 

            TIpcArgs( &iReqData, &devicePropertyValuePckg ) );

        }

    API_TRACE( ( _L( "CHWRMHapticsImpl::GetDeviceProperty() - TInt overloaded - return %d" ), err ) );

    return err;

    }

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

// GetDeviceProperty() - TDes8 overload for aDevicePropertyValue parameter

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

//

TInt CHWRMHapticsImpl::GetDeviceProperty( TInt aDevicePropertyType, 

                                          TDes8& aDevicePropertyValue )

    {

    __ASSERT_DEBUG( iPacketizer, User::Panic( KPanic, EPanicNotReady ) );

    if ( !iPacketizer )

        {

        return EPanicNotReady;

        }

    API_TRACE( ( _L( "CHWRMHapticsImpl::GetDeviceProperty() - TDes8 overloaded - aDevicePropertyType(%d), aDevicePropertyValue(0x%x)" ), aDevicePropertyType, &aDevicePropertyValue ) );

    TInt err( KErrNone );

    if( aDevicePropertyValue.MaxLength() < MaxPropertyStringLength() ) 

        {

        err = KErrArgument;

        }

    if ( KErrNone == err )

        {

        // encode the request

        iReqData.Close();

        err = iPacketizer->EncGetDevicePropertyStringReq( 

                    iDeviceHandle, aDevicePropertyType, iReqData );

        if ( KErrNone == err )

            {

            err = iClient.ExecuteOperation( 

                    EHWRMHaptics, 

                    TIpcArgs( &iReqData, &aDevicePropertyValue ) );

            }

        }