/*

* 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 the License "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 test (adaptation) plugin implementation.

*

*/

#include <s32mem.h>

#include <hwrmhapticscommands.h>

#include "hwrmhapticsstubplugin.h"

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

// Static instantiation method.

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

//

CHWRMHapticsStubPlugin* CHWRMHapticsStubPlugin::NewL( 

                                    MHWRMHapticsPluginCallback* aCallback )

    {

    CHWRMHapticsStubPlugin* self = 

        new ( ELeave ) CHWRMHapticsStubPlugin( aCallback );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor

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

//

CHWRMHapticsStubPlugin::~CHWRMHapticsStubPlugin()

    {

    iResponders.ResetAndDestroy();

    if ( iIdle )

        {

        iIdle->Cancel();

        delete iIdle;

        }

    }

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

// Implementation of ProcessCommandL. Creates an idle responder and appends it

// to the array of idle responders. (Later then, when the responder gets 

// runtime, it will initiate the response generation).

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

//

void CHWRMHapticsStubPlugin::ProcessCommandL( TInt aCommandId,

                                              TUint8 aTransId,

                                              TDesC8& aData )

    {

    if ( aCommandId != HWRMHapticsCommand::EHapticsCmdId ||

         aData.Size() < 2 ) // minimum length check

        {

        User::Leave( KErrBadDescriptor );

        }

    TUint8* dataPtr = const_cast<TUint8*>( aData.Ptr() );

    if ( !dataPtr )

        {

        User::Leave( KErrBadDescriptor );

        }

    CHWRMHapticsStubPluginIdleResponder* responder = 

        CHWRMHapticsStubPluginIdleResponder::NewL( this, aTransId, dataPtr );

    CleanupStack::PushL( responder );

    iResponders.AppendL( responder );

    CleanupStack::Pop ( responder );

    }

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

// Implementation of CancelCommandL. Just removes the corresponding idle 

// responder.

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

//

void CHWRMHapticsStubPlugin::CancelCommandL( TUint8 aTransId, 

                                             TInt /* aCommandId */ )

    {

    RemoveResponder( aTransId );

    }

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

// Method that does the actual response generation towards the issuer of 

// command i.e., the HapticsPluginManager

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

//

void CHWRMHapticsStubPlugin::GenerateResponseL( TUint8 aTransId,

                                                TUint8* aData )

    {

    // Hardcoded responses generated based on the command code (first 2 bytes

    // of the aData data packet, but since at the moment the 2nd byte is 

    // always 0x00, we just use the 1st one)

    TUint8 command = aData[0];

    TBuf8<KHWRMHapticsRespMaxSize> binRespData;

    binRespData.SetLength( KHWRMHapticsRespMaxSize );

    TInt i( 0 );

    // For each command the response data's first two bytes are copy of

    // the received command code (first 2 bytes of aData).

    binRespData[i++] = aData[0]; // command code bits 0..7

    binRespData[i++] = aData[1]; // command code bits 8..15

    switch ( command )

        {

        case 0x00: // API version query

            {

            // Response to API version query contains:

            //      1 byte major version number

            //      1 byte minor version number

            //      2 bytes for build version

            binRespData[i++] = 0x02; // major version

            binRespData[i++] = 0x00; // minor version

            binRespData[i++] = 0x53; // build version bits 0..7

            binRespData[i++] = 0x04; // build version bits 8..15

            break;    

            }

        case 0x01: // Initialize

        case 0x02: // Terminate

        case 0x06: // Modify basis effect

        case 0x07: // Stop effect

        case 0x08: // Stop all effects

        case 0x0B: // Reset debug buffer

        case 0x0C: // Stop designed bridge

        case 0x13: // Close device

        case 0x14: // Start designed bridge

        case 0x16: // Play streaming sample

        case 0x18: // Destroy streaming effect

        case 0x19: // Pause playing effect

        case 0x1A: // Resume playing effect

        case 0x1E: // Modify magsweep effect

        case 0x1F: // Modify periodic effect

            {

            // For these commands the response only contains status byte 

            // (set to 0x00 ("Success") in this stub).

            binRespData[i++] = 0x00; // status

            break;

            }

        case 0x03: // Play basis effect

        case 0x04: // Play IVT effect (with IVT data)

        case 0x05: // Play IVT effect (without IVT data)

        case 0x17: // Create streaming effect

        case 0x1C: // Play magsweep effect

        case 0x1D: // Play periodic effect

            {

            // The response consists of status byte (0x00) and 4-byte long

            // effectHandle (here hardcoded as 0x01000000)

            binRespData[i++] = 0x00; // status

            binRespData[i++] = 0x01; // effectHandle bits 0..7

            binRespData[i++] = 0x00; // effectHandle bits 8..15

            binRespData[i++] = 0x00; // effectHandle bits 16..23

            binRespData[i++] = 0x00; // effectHandle bits 24..31

            break;    

            }

        case 0x09: // Get device capabilities

            {

            // The response consists of status byte (0x00), 4-byte long

            // capability type (copied from the received command (bytes 

            // 7..10)), 1-byte capability  value type (copied from the 

            // received command (byte 2), 1-byte size byte and "size" bytes

            // long value

            binRespData[i++] = 0x00;      // status

            binRespData[i++] = aData[7];  // capability type bits 0..7

            binRespData[i++] = aData[8];  // capability type bits 8..15

            binRespData[i++] = aData[9];  // capability type bits 16..23

            binRespData[i++] = aData[10]; // capability type bits 24..31

            binRespData[i++] = aData[2];  // capability value type

            // The size and value depend on what exactly is being queried

            // Note: Currently only the lowest (0..7) bytes of capability

            //       type have meaning, thus the switch case below is 

            //       simplified..

            // Note: Since all values, except device name, are actually 32-bit

            //       integers, their size is always 4.

            TUint8 capabilityType = aData[7];

            switch ( capabilityType )

                {

                case 0: // device category

                    {

                    binRespData[i++] = 0x04; // size

                    binRespData[i++] = 0x02;

                    binRespData[i++] = 0x00;

                    binRespData[i++] = 0x00;

                    binRespData[i++] = 0x00; // value - virtual device

                    break;    

                    }

                case 1: // max nested repeats

                case 2: // num of actuators

                case 4: // num of effect slots

                case 6: // min period

                    {

                    binRespData[i++] = 0x04; // size

                    binRespData[i++] = 0x01;

                    binRespData[i++] = 0x00;

                    binRespData[i++] = 0x00;

                    binRespData[i++] = 0x00; // value - 0x1

                    break;  

                    }

                case 3: // actuator type

                    {

                    binRespData[i++] = 0x04; // size

                    binRespData[i++] = 0x00;

                    binRespData[i++] = 0x00;

                    binRespData[i++] = 0x00;

                    binRespData[i++] = 0x00; // value - ERM actuator

                    break;    

                    }

                case 5: // supported styles

                    {

                    binRespData[i++] = 0x04; // size

                    binRespData[i++] = 0x07;

                    binRespData[i++] = 0x00;

                    binRespData[i++] = 0x00;

                    binRespData[i++] = 0x00; // value - all styles   

                    break;

                    }

                case 7:  // max period 

                case 8:  // max effect duration

                case 11: // max envelope time

                case 13: // max IVT file size (tethered)

                case 14: // max IVT file size

                    {

                    binRespData[i++] = 0x04; // size

                    binRespData[i++] = 0xFF;

                    binRespData[i++] = 0xFF;

                    binRespData[i++] = 0x00; // 

                    binRespData[i++] = 0x00; // value => 0xFFFF.

                    break;    

                    }

                case 9: // supported effects

                    {

                    binRespData[i++] = 0x04; // size

                    binRespData[i++] = 0x07;

                    binRespData[i++] = 0x00;

                    binRespData[i++] = 0x00;

                    binRespData[i++] = 0x00; // value - mag|per|timeline   

                    break;

                    }

                case 10: // device name

                    {

                    binRespData[i++] = 0x04;  // size

                    binRespData[i++] = 0x52;  // value - byte 1, ascii "S"

                    binRespData[i++] = 0x53;  // value - byte 2, ascii "T"

                    binRespData[i++] = 0x54;  // value - byte 3, ascii "U"

                    binRespData[i++] = 0x42;  // value - byte 4, ascoo "B"

                    break;   

                    }

                case 12: // API version number

                    {

                    binRespData[i++] = 0x04; // size

                    binRespData[i++] = 0x02;

                    binRespData[i++] = 0x00;

                    binRespData[i++] = 0x00;

                    binRespData[i++] = 0x00; // value - API version 

                                             // Note: same as major version in

                                             // specific API version query

                                             // 0x2

                    break;

                    }

                default:

                    {

                    // Here status byte changed to -6 (0xFA)

                    // ("incompatible capability type")

                    binRespData[2]   = 0xFA; // status (re-assigned)

                    binRespData[i++] = 0x00; // value size set to zero

                    break;

                    }

                } // inner switch ends

            break;    

            }

        case 0x0A: // Get debug buffer

            {

            // The response consists of status byte (0x00) and 2 bytes

            // indicating the buffer size followed by the buffer itself.

            // Here buffer size zero is used => thus this only consists of

            // 3 bytes

            // FFS: This may have to be changed if the zero-length is not ok.

            binRespData[i++] = 0x00; // status

            binRespData[i++] = 0x00; // buffer size bits 0..7

            binRespData[i++] = 0x00; // buffer size bits 8..15

            break;    

            }

        case 0x0D: // Get device state

            {

            // The response consists of status byte (0x00) and 4 bytes that

            // indicate the device state (the bytes used here mean 

            // "device attached to the system")

            binRespData[i++] = 0x00; // status

            binRespData[i++] = 0x01; // device state bits 0..7

            binRespData[i++] = 0x00; // device state bits 8..15

            binRespData[i++] = 0x00; // device state bits 16..23

            binRespData[i++] = 0x00; // device state bits 24..31

            break;    

            }

        case 0x0E: // Set kernel param

            {

            // The response consists of status byte (0x00) and 2 bytes that

            // are the kernel param Id's copied from the received command 

            // (bytes 6 and 7)

            binRespData[i++] = 0x00;     // status

            binRespData[i++] = aData[6]; // kernel param Id bits 0..7

            binRespData[i++] = aData[7]; // kernel param Id bits 8..15

            break;    

            }

        case 0x0F: // Get kernel param

            {

            // The response consists of status byte (0x00), 2 bytes that are

            // the kernel param Id's copied from the received command 

            // (bytes 6&7) and two bytes for (here dummy 0x00) values

            binRespData[i++] = 0x00;     // status

            binRespData[i++] = aData[6]; // kernel param Id bits 0..7

            binRespData[i++] = aData[7]; // kernel param Id bits 8..15

            binRespData[i++] = 0x00;     // kernel param value bits 0..7

            binRespData[i++] = 0x00;     // kernel param value bits 8..15

            break;    

            }

        case 0x10: // Set device property

            {

            // The response consists of status byte (0x00), 4 bytes indicating

            // the property type (copied from the received command's bytes 

            // 6..9) and 1 byte indicating the property value type (copied

            // from the received command's byte 10).

            binRespData[i++] = 0x00;      // status

            binRespData[i++] = aData[6];  // property type bits 0..7

            binRespData[i++] = aData[7];  // property type bits 8..15

            binRespData[i++] = aData[8];  // property type bits 16..23

            binRespData[i++] = aData[9];  // property type bits 24..31

            binRespData[i++] = aData[10]; // property value type

            break;    

            }

        case 0x11: // Get device property

            {

            // The response consists of 1-byte status (0x00), 4-byte long

            // property type (copied from the received command bytes 7..10),

            // 1-byte property value type (copied from the received command

            // byte 2), 1-byte size byte and "size" bytes long value part

            binRespData[i++] = 0x00;      // status

            binRespData[i++] = aData[7];  // property type bits 0..7

            binRespData[i++] = aData[8];  // property type bits 8..15

            binRespData[i++] = aData[9];  // property type bits 16..23

            binRespData[i++] = aData[10]; // property type bits 24..31

            binRespData[i++] = aData[2];  // property value type

            // The size and value depend on what exactly is being queried

            // Note: Currently only the lowest (0..7) bytes of capability type

            //       have meaning, thus the switch case below is simplified

            TUint8 propertyType = aData[7];

            switch ( propertyType )

                {

                case 0: 

                    // license key.. not feasible as GET device property type

                    {

                    // re-assign the status

                    binRespData[2]   = 0xF9; // status - incompatible property

                                             //          type

                    binRespData[i++] = 0x00; // value size == 0 (=> no value)                    

                    break;

                    }

                case 1: // priority

                    {

                    binRespData[i++] = 0x04; // size (32-bit integer takes 4

                                             // bytes)

                    binRespData[i++] = 0x00;

                    binRespData[i++] = 0x00;

                    binRespData[i++] = 0x00;

                    binRespData[i++] = 0x00; // value - 0x0 is lowest priority

                    break;

                    }

                case 2: // disable effects

                    {

                    binRespData[i++] = 0x04; // size 

                    binRespData[i++] = 0x00;

                    binRespData[i++] = 0x00;

                    binRespData[i++] = 0x00;

                    binRespData[i++] = 0x00; // value - 0x0 means not disabled

                    break;

                    }

                case 3: // strength

                case 4: // master strength

                    {

                    binRespData[i++] = 0x04; // size 

                    binRespData[i++] = 0xFF;

                    binRespData[i++] = 0xFF;

                    binRespData[i++] = 0x00;

                    binRespData[i++] = 0x00; // => value 0xFFFF

                    break;

                    }

                default:

                    {

                    // Pehaps it's best to change the status byte to -7 (0xF9)

                    // ("incompatible property type")

                    binRespData[2]   = 0xF9; // status (re-assigned)

                    binRespData[i++] = 0x00; // value size, set to zero

                    break;    

                    }

                } // inner switch ends

            break;    

            }

        case 0x12: // Open device

            {

            // The response consists of status byte (0x00) and 4-byte long

            // deviceHandle (here hardcoded as 0x01000000)

            binRespData[i++] = 0x00; // status

            binRespData[i++] = 0x01; // deviceHandle bits 0..7

            binRespData[i++] = 0x00; // deviceHandle bits 8..15

            binRespData[i++] = 0x00; // deviceHandle bits 16..23

            binRespData[i++] = 0x00; // deviceHandle bits 24..31

            break;    

            }

        case 0x15: // Device count

            {

            // The response only contains the device count (here value == 1)

            binRespData[i++] = 0x01;

            break;    

            }

        case 0x1B: // Get effect state

            {

            // The response consists of status byte (0x00) and one byte effect

            // state (0x00 used here meaning "Not playing")

            binRespData[i++] = 0x00; // status

            binRespData[i++] = 0x00; // effect state 

            break;

            }

        case 0x20: // Load IVT data

            {

            // The response consists of status byte (0x00) and 4-byte long

            // fileHandle (here hardcoded as 0x01000000)

            binRespData[i++] = 0x00; // status

            binRespData[i++] = 0x01; // fileHandle bits 0..7

            binRespData[i++] = 0x00; // fileHandle bits 8..15

            binRespData[i++] = 0x00; // fileHandle bits 16..23

            binRespData[i++] = 0x00; // fileHandle bits 24..31

            break;    

            }

        case 0x30: // Get license key

            {

            binRespData[i++] = 0x00; // status

            binRespData[i++] = 0x20; // size

            for( TInt n=0; n<0x20; )

                {

                binRespData[i++] = 0x53; // S

                n++;

                binRespData[i++] = 0x54; // T

                n++;

                binRespData[i++] = 0x55; // U

                n++;

                binRespData[i++] = 0x42; // B

                n++;

                }

            break;

            }

        case 0xFF: // Protocol version query

            {

            // Response to Protocol version query contains:

            //      1 byte minor version number

            //      1 byte major version number

            binRespData[i++] = 0x00; // minor version 

            binRespData[i++] = 0x03; // major version

            break;    

            }

        default:

            {

            // Unknown command.. 

            break;    

            }

        } // switch ends 

    // set the lenght of the raw response data

    binRespData.SetLength( i );

    // create Haptics response data. This is done by externalizing 

    // (with RDesWriteStream whose sink is the Haptics response data)

    TInt32 respDataErr( KErrNone );

    CHWRMHapticsRespData* respData = 

        CHWRMHapticsRespData::NewLC( respDataErr, binRespData );

    HWRMHapticsCommand::RHWRMHapticsRespData resp;

    resp.CreateL( KHWRMHapticsRespMaxSize );

    CleanupClosePushL( resp );

    RDesWriteStream streamWriter( resp );

    CleanupClosePushL( streamWriter );

    streamWriter << *respData;

    // This commits to stream's sink (i.e., to 'resp')

    CleanupStack::PopAndDestroy( &streamWriter );

    // Call the ProcessResponseL of the HapticsPluginManager

    // object that created this stub plugin instance.

    iResponseCallback->ProcessResponseL

        ( HWRMHapticsCommand::EHapticsCmdId, aTransId, resp );    

    CleanupStack::PopAndDestroy( &resp );

    CleanupStack::PopAndDestroy( respData );

    // Order garbage collection of "spent" responder(s), if not already

    // waiting for scheduling

    if ( !iIdle->IsActive() )

        {

        iIdle->Start( TCallBack ( CollectGarbageIdle, this ) );    

        }         

    }

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