/*
* Copyright (c) 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:  Client interface to haptics server for haptics bridge 
*                commands.
*
*/


#include <e32svr.h>
#include <f32file.h>
#include <data_caging_path_literals.hrh> // KDC_PROGRAMS_DIR
#include <hwrmhaptics.h>
#include <hwrmlogicalactuators.h>
#include <hwrmhapticspacketizer.h>

#include "hapticsbridgeclient.h"
#include "hapticsconntrace.h"

const TInt KServerVersionMajor       = 1;
const TInt KServerVersionMinor       = 1;
const TInt KServerVersionBuild       = 1;
_LIT( KServerProcessName, "!hwrmhapticsserver" );
_LIT( KServerExeName, "hwrmhapticsserver.exe" );
const TInt KAsyncMsgSlots = 10;

const TInt KHWRMHapticsServiceCommand      = 2001;
const TInt KHWRMHapticsOpenActuatorCommand = 2004;
const TInt KHWRMHapticsCleanupCommand      = 2008;
const TInt KHWRMHapticsBridgeCommand       = 2011;

// --------------------------------------------------------------------------
// Simple constructor
// 
// --------------------------------------------------------------------------
// 
RHapticsBridgeClient::RHapticsBridgeClient()
    {
    TRAP_IGNORE( iPacketizer = 
                 CHWRMHapticsPacketizer::NewL( EHWRMLogicalActuatorAny ) );
    }

// --------------------------------------------------------------------------
// Simple destructor
// 
// --------------------------------------------------------------------------
// 
RHapticsBridgeClient::~RHapticsBridgeClient()
    {
    delete iPacketizer;
    }

// --------------------------------------------------------------------------
// Method for connecting (creating a new session) with Haptics Server
// 
// --------------------------------------------------------------------------
// 
TInt RHapticsBridgeClient::Connect()
    {
    COMPONENT_TRACE( ( _L( "RHapticsBridgeClient::Connect()" ) ) );
    TInt ret = CreateSession( KServerProcessName, 
                              ServerVersion(), 
                              KAsyncMsgSlots );
    if ( ret != KErrNone )
        {
        ret = StartServer();
        if ( ret == KErrNone )
            {
            ret = CreateSession( KServerProcessName, 
                                 ServerVersion(),
                                 KAsyncMsgSlots );    
            COMPONENT_TRACE(_L("RHapticsBridgeClient::Connect(), Session created"));
            }       
        }

    // Initialize server components.
    if ( ret == KErrNone )
        {
        ret = SendReceive( KHWRMHapticsServiceCommand );
        }

    // Open the haptic effect ("vibra") device.
    if ( ret == KErrNone )
        {
        ret = OpenHapticsDevice();
        }
    
        
    COMPONENT_TRACE( ( _L( "RHapticsBridgeClient::Connect - return(%d)" ), ret ) );        
    return ret;
    }

// --------------------------------------------------------------------------
// Method for starting Haptics Server (if not already running)
// 
// --------------------------------------------------------------------------
//
TInt RHapticsBridgeClient::StartServer() const
    {
    COMPONENT_TRACE( ( _L( "RHapticsBridgeClient::StartServer()" ) ) );

    TParse parser;
    parser.Set( KServerExeName, &KDC_PROGRAMS_DIR, NULL );
        
    RProcess server;
    TInt ret = server.Create( parser.FullName(), KNullDesC );

    if ( ret != KErrNone ) // Loading failed.
        {
        return ret;
        }

    TRequestStatus status;
    server.Rendezvous( status );

    if ( status != KRequestPending )
        {
        server.Kill( 0 ); // Abort startup.
        server.Close();
        return KErrGeneral;
        }
    else
        {
        server.Resume(); // Logon OK - start the server.
        }
        
    User::WaitForRequest( status );
    server.Close();

    COMPONENT_TRACE( ( _L( "RHapticsBridgeClient::StartServer() - return %d" ), status.Int() ) );
    return status.Int();    
    }

// --------------------------------------------------------------------------
// Method for closing session to haptics server.
// 
// --------------------------------------------------------------------------
//    
void RHapticsBridgeClient::Close()    
    {
    RSessionBase::Close();
    }

// --------------------------------------------------------------------------
// Getter method for server version.
// 
// --------------------------------------------------------------------------
//
TVersion RHapticsBridgeClient::ServerVersion() const 
    {
    return TVersion( KServerVersionMajor, 
                     KServerVersionMinor,
                     KServerVersionBuild );
    }

// --------------------------------------------------------------------------
// Method for sending commands to Haptics Server.
// 
// --------------------------------------------------------------------------
//    
TInt RHapticsBridgeClient::SendBridgeBuffer( const TDesC8& aReqData, TDes8& aRetDataPckg )
    {
    COMPONENT_TRACE( ( _L( "RHapticsBridgeClient::SendBridgeBufferL() - Begin" ) ) );

    TInt retVal( KErrDisconnected );
    if ( iHandle )
        {
        TInt vibeStatus(0);
        TPckg<TInt> vibeStatusPckg( vibeStatus );
        retVal = SendReceive( KHWRMHapticsBridgeCommand, 
                              TIpcArgs( &aReqData, 
                                        &vibeStatusPckg, 
                                        &aRetDataPckg ) );

        if ( retVal == KErrNone ) 
            {
            TRAP( retVal, HandleOpenDeviceResponseL( aRetDataPckg ) );
            }
        }
    
    COMPONENT_TRACE( ( _L( "RHapticsBridgeClient::SendBridgeBufferL() - End (%d)" ), retVal ) );    
    return retVal;
    }

// --------------------------------------------------------------------------
// Method for cleaning up session to Haptics Server.
// 
// --------------------------------------------------------------------------
//
void RHapticsBridgeClient::CleanUp()
    {
    COMPONENT_TRACE( ( _L( "RHapticsBridgeClient::CleanUp() - Begin" ) ) );
    if ( iHandle )
        {
        SendReceive ( KHWRMHapticsCleanupCommand );
        }
    COMPONENT_TRACE( ( _L( "RHapticsBridgeClient::CleanUp() - End" ) ) );
    }

// --------------------------------------------------------------------------
// Method for handling Open Device responses (basically for requesting the 
// setting of the license key).
// 
// --------------------------------------------------------------------------
//
void RHapticsBridgeClient::HandleOpenDeviceResponseL( const TDesC8& aResponse )
    {
    COMPONENT_TRACE( ( _L( "RHapticsBridgeClient::HandleOpenDeviceResponse() - Begin" ) ) );
    TInt err( KErrNone );
    if ( !iPacketizer )
        {
        COMPONENT_TRACE( ( _L( "RHapticsBridgeClient::HandleOpenDeviceResponse() - No Packetizer!" ) ) );
        User::Leave( KErrGeneral );
        }
    else    
        {
        const TUint8* pRsp ( aResponse.Ptr() );
        if ( 0x12 == pRsp[0] && 0x00 == pRsp[1] && 0x00 == pRsp[2] )
            {
            COMPONENT_TRACE( ( _L( "RHapticsBridgeClient::HandleOpenDeviceResponse() - OPEN DEVICE RESPONSE handling" ) ) );
            iPacketizer->DecodeMessageL( aResponse, err );
            if ( !err )
                {
                RBuf8 reqBuf;
                err = iPacketizer->EncSetPlatformLicenseKeyReq( 
                    iPacketizer->DeviceHandle(), reqBuf );
                if ( !err )
                    {
                    TBuf8<50> dummyRetBuf;
                    TInt dummyStatus;
                    TPckg<TInt> dummyStatusPckg( dummyStatus );
                    err = SendReceive( KHWRMHapticsBridgeCommand, 
                                       TIpcArgs ( &reqBuf,
                                                  &dummyStatusPckg, 
                                                  &dummyRetBuf ) );
                    COMPONENT_TRACE( ( _L( "RHapticsBridgeClient::HandleOpenDeviceResponse() - Sent set license command (%d)"), err ) );
                    }
                reqBuf.Close();
                }
            User::LeaveIfError( err );
            }
        }
    COMPONENT_TRACE( ( _L( "RHapticsBridgeClient::HandleOpenDeviceResponse() - End" ) ) );
    }


// --------------------------------------------------------------------------
// Method for opening haptics device. This is needed since there's possibility
// that no other haptics client has opened the device prior to this bridge
// connectivity. This method also call set license key, i.e., completes the
// device opening. 
//
// --------------------------------------------------------------------------
//
TInt RHapticsBridgeClient::OpenHapticsDevice()
    {
    COMPONENT_TRACE( ( _L( "RHapticsBridgeClient::OpenHapticsDevice - Begin" ) ) );
    TInt err( KErrGeneral );
    if ( iPacketizer )
        {
        RBuf8 openDevReqBuf;
        RBuf8 setLicenseReqBuf;
        TBuf8<50> setLicenseRspBuf;
        TInt dummyStatus;
        TPckg<TInt> dummyStatusPckg( dummyStatus );
        
        err = iPacketizer->EncOpenDeviceReq( EHWRMLogicalActuatorAny,
                                             openDevReqBuf );

        COMPONENT_TRACE( ( _L( "RHapticsBridgeClient::OpenHapticsDevice - EncOpenDevice (%d)" ), err ) );
        if ( !err )
            {
            TInt deviceHandle;
            TPckg<TInt> deviceHandlePckg( deviceHandle );
            err = SendReceive( KHWRMHapticsOpenActuatorCommand,
                               TIpcArgs ( &openDevReqBuf, 
                                          &deviceHandlePckg,
                                          EHWRMLogicalActuatorAny ) );
            COMPONENT_TRACE( ( _L( "RHapticsBridgeClient::OpenHapticsDevice - Send OpenDevice (%d)" ), err ) );
            COMPONENT_TRACE( ( _L( "RHapticsBridgeClient::OpenHapticsDevice - Device handle = %d" ), deviceHandle ) );
            if ( !err )
                {
                err = iPacketizer->EncSetPlatformLicenseKeyReq( 
                    deviceHandle, setLicenseReqBuf );
                COMPONENT_TRACE( ( _L( "RHapticsBridgeClient::OpenHapticsDevice - EncSetEmptyLicenseKey (%d)" ), err ) );    
                if ( !err )
                    {
                    TBuf8<50> dummyRspBuf;
                    TInt dummyStatus;
                    TPckg<TInt> dummyStatusPckg( dummyStatus );
                    err = SendReceive( KHWRMHapticsBridgeCommand, 
                                       TIpcArgs ( &setLicenseReqBuf,
                                                  &dummyStatusPckg, 
                                                  &dummyRspBuf ) );
                    COMPONENT_TRACE( ( _L( "RHapticsBridgeClient::OpenHapticsDevice - Send SetLicense (%d)" ), err ) );
                    }
                }
            }

        openDevReqBuf.Close();
        setLicenseReqBuf.Close();
        }
    COMPONENT_TRACE( ( _L( "RHapticsBridgeClient::OpenHapticsDevice - End (err=%d)" ),err ) );    
    return err;
    }

// eof