/*

* Copyright (c) 2004 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:  This is the implementation of application class

 *

*/

#include <e32std.h>

#include <e32svr.h>

#include <w32std.h>

#include <coedef.h>

#include <eiksvdef.h>

#include <apgcli.h>

#include <apgtask.h>

#include <apacmdln.h>

#include <e32property.h>

#include "hidtranslate.h"

#include "finder.h"

#include "keyboard.h"

#include "layoutmgr.h"

#include "debug.h"

#include "timeouttimer.h"

#include "layoututils.h"

#include "bthidPsKey.h"

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

// Application UIDs for finding window groups.

const TInt KIdleAppUid = 0x102750f0;

const TInt KPhoneAppUid = 0x100058b3;

const TInt KMenuAppUid = 0x101f4cd2;

const TInt KSysApUid = 0x100058f3;

const TInt KActiveNotesUid = 0x10281a31;

const TInt KMessagingUid = 0x100058C5;

const TInt KServicesUid = 0x10008D39;

//const TInt KMultimediaMenuUid = 0x10281cfb;

// Key repeat parameters to be configured

const TInt KRepeatEndTimeout = 5000000; // 5 seconds

const TInt KKeyRepeatDelay = 500000;

const TInt KKeyRepeatInterval = 75000;

_LIT(KAppName, "PaintCursor.exe");

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

// CHidKeyboardDriver::CHidKeyboardDriver

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

//

CHidKeyboardDriver::CHidKeyboardDriver(MDriverAccess* aGenericHid) :

    iDriverState(EUninitialised), iGenericHid(aGenericHid), iMmKeyDown(0)

    {

        TRACE_INFO( (_L("[HID]\tCHidKeyboardDriver::CHidKeyboardDriver(0x%08x)"), aGenericHid));

    }

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

// CHidKeyboardDriver::NewLC

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

//

CHidKeyboardDriver* CHidKeyboardDriver::NewLC(MDriverAccess* aGenericHid)

    {

        TRACE_INFO( (_L("[HID]\tCHidKeyboardDriver::NewLC(0x%08x)"), aGenericHid));

    CHidKeyboardDriver* self = new (ELeave) CHidKeyboardDriver(aGenericHid);

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

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

// CHidKeyboardDriver::NewL

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

//

CHidKeyboardDriver* CHidKeyboardDriver::NewL(MDriverAccess* aGenericHid)

    {

    CHidKeyboardDriver* self = CHidKeyboardDriver::NewLC(aGenericHid);

    CleanupStack::Pop();

    return self;

    }

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

// CHidKeyboardDriver::ConstructL

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

//

void CHidKeyboardDriver::ConstructL()

    {

        TRACE_INFO( (_L("[HID]\tCHidKeyboardDriver{0x%08x}::ConstructL()"), this));

    User::LeaveIfNull(iGenericHid);

    // Create a session with the window server:

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

    // Create a session with the layout manager:

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

    // We also need a key repeat timer:

    iRepeatTimer = CPeriodic::NewL(CActive::EPriorityStandard);

    // repeat ending timer

    iRepeatEndTimer = CTimeOutTimer::NewL(EPriorityNormal, *this);

    iAppMenuId = AppMenuId();

    iPhoneAppId = PhoneAppId();

    iIdleAppId = IdleAppId();

    iComboDevice = EFalse;

    iSettings = CBtHidSettings::NewL();

    }

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

// CHidKeyboardDriver::~CHidKeyboardDriver

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

//

CHidKeyboardDriver::~CHidKeyboardDriver()

    {

        TRACE_INFO( (_L("[HID]\t~CHidKeyboardDriver() 0x%08x"), this));

    CancelAllKeys();

    delete iRepeatTimer;

    delete iRepeatEndTimer;

    iWsSession.Close();

    iLayoutMgr.Close();

    for (TInt i = 0; i < KNumInputFieldTypes; ++i)

        {

        iKeys[i].Reset();

        }

    iPointBufQueue.Close();

    if (iComboDevice)

        {

        RProperty::Set( KPSUidBthidSrv, KBTMouseCursorState, ECursorHide );

        }

    if (iSettings)

        delete iSettings;

    }

void CHidKeyboardDriver::MoveCursor(const TPoint& aPoint)

    {

    DBG(RDebug::Print(

                    _L("CHidKeyboard::MoveCursor")));

    PostPointer(aPoint);

    }

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

// CHidMouseDriver::PostPointer

// Save the event to the buffer

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

//

TInt CHidKeyboardDriver::PostPointer(const TPoint& aPoint)

    {

    DBG(RDebug::Print(_L("CHidKeyboard::PostPointer")));

    iPointerBuffer.iPoint[iPointerBuffer.iNum] = aPoint;

    iPointerBuffer.iType[iPointerBuffer.iNum] = KBufferPlainPointer;

    iPointerBuffer.iNum++;

    TInt ret = KErrNone;

    if (iPointerBuffer.iNum > KPMaxEvent)

        {

        ret = iPointBufQueue.Send(iPointerBuffer);

        iPointerBuffer.iNum = 0;

        }

    return ret;

    }

TInt CHidKeyboardDriver::SendButtonEvent(TBool aButtonDown)

    {

    DBG(RDebug::Print(

                    _L("CHidKeyboard::SendButtonEvent")));

    iPointerBuffer.iPoint[iPointerBuffer.iNum] = TPoint(0, 0);

    iPointerBuffer.iType[iPointerBuffer.iNum] = aButtonDown

                                                            ? KBufferPenDown

                                                               : KBufferPenUp;

    iPointerBuffer.iNum++;

    TInt ret = iPointBufQueue.Send(iPointerBuffer);

    iPointerBuffer.iNum = 0;

    return ret;

    }

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

// CHidKeyboardDriver:::StartL

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

//

void CHidKeyboardDriver::StartL(TInt aConnectionId)

    {

        TRACE_INFO( (_L("[HID]\tCHidKeyboardDriver::StartL")));

    aConnectionId = aConnectionId;

    // No keys are pressed:

    iModifiers = 0;

    for (TInt i = 0; i < KNumInputFieldTypes; ++i)

        {

        if (iField[i])

            {

            // Reset the keys pressed array to all zeros

            RArray<TInt>& keys = iKeys[i];

            for (TInt j = 0; j < keys.Count(); j++)

                {

                keys[j] = 0;

                }

            }

        }

    // Start up with Num Lock active:

    iLockState = ENumLock;

    SetKeyboardLeds();

    //In case of reconnection, try to initialize the Keybord driver...

    InitialiseL(aConnectionId);

    // Reset the state of the layout decoder:

    iLayoutMgr.Reset();

    TInt initialLayout;

    User::LeaveIfError(iLayoutMgr.GetLayout(initialLayout));

    iLastSelectedLayout = iSettings->LoadLayoutSetting();

    TBool sameCategory = CLayoutUtils::SameCategory(

            static_cast<THidKeyboardLayoutId> (initialLayout),

            iLastSelectedLayout);

    if (sameCategory)

        {

        //Used the layoutID from CenRep

        iLayoutMgr.SetLayout(iLastSelectedLayout);

        }

    TInt err = iPointBufQueue.OpenGlobal(KMsgBTMouseBufferQueue);   

    if (err == KErrNotFound)

        {

        User::LeaveIfError(iPointBufQueue.CreateGlobal(KMsgBTMouseBufferQueue, KPointQueueLen));    

        }

    else

        {

        User::LeaveIfError( err );

        }    

    // Ready to process keyboard events:

    iDriverState = EInitialised;

    if (iComboDevice)

        {

        LaunchApplicationL(KAppName);

        RProperty::Set( KPSUidBthidSrv, KBTMouseCursorState, ECursorShow );

        }

    }

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

// CHidKeyboardDriver::InitialiseL

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

//

void CHidKeyboardDriver::InitialiseL(TInt aConnectionId)

    {

        TRACE_INFO( (_L("[HID]\tCHidKeyboardDriver::InitialiseL(%d)"),

                        aConnectionId));

    // Store the connection ID:

    iConnectionId = aConnectionId;

    // Initialise the layout manager:

    TInt country = iGenericHid->CountryCodeL(aConnectionId);

    TInt vendor = iGenericHid->VendorIdL(aConnectionId);

    TInt product = iGenericHid->ProductIdL(aConnectionId);

        TRACE_INFO( (

                        _L("[HID]\t  Country = %d, vendor = %d, product = %d"),

                        country, vendor, product));

    User::LeaveIfError(iLayoutMgr.SetInitialLayout(country, vendor, product));

    }

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

// CHidKeyboardDriver::Stop

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

//

void CHidKeyboardDriver::Stop()

    {

    iDriverState = EDisabled;

    CancelAllKeys();

    if (iComboDevice)

        {

        RProperty::Set( KPSUidBthidSrv, KBTMouseCursorState, ECursorHide );

        }

    }

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

// CHidMouseDriver::LaunchApplicationL

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

//

void CHidKeyboardDriver::LaunchApplicationL(const TDesC& aName)

    {

    //Check if application is already running in the background

    TApaTaskList tasks(iWsSession);

    TApaTask task = tasks.FindApp(aName);

    if (task.Exists())

        {

        // Application is active, so just bring to foreground

        }

    else

        {

        // If application is not running, then create a new one

        CApaCommandLine* cmd = CApaCommandLine::NewLC();

        cmd->SetExecutableNameL(aName);

        cmd->SetCommandL(EApaCommandBackground); // EApaCommandRun

        RApaLsSession arcSession;

        //connect to AppArc server

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

        CleanupClosePushL(arcSession);

        User::LeaveIfError(arcSession.StartApp(*cmd));

        arcSession.Close();

        CleanupStack::PopAndDestroy(2);

        }

    }

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

// CHidDriver mandatory functions:

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

// CHidKeyboardDriver::DataIn

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

//

TInt CHidKeyboardDriver::DataIn(CHidTransport::THidChannelType aChannel,

        const TDesC8& aPayload)

    {

    TInt err = KErrNone;

    switch (aChannel)

        {

        case CHidTransport::EHidChannelInt:

            if (EInitialised == iDriverState)

                {

                if (iComboDevice)

                    {

                    TInt mouseStatus;

                    TInt err = RProperty::Get( KPSUidBthidSrv, KBTMouseCursorState, mouseStatus );

                    if ( !err && (static_cast<THidMouseCursorState>(mouseStatus) == ECursorHide) )

                        {

                        err = RProperty::Set( KPSUidBthidSrv, KBTMouseCursorState, ECursorShow );

                        }

                    }

                InterruptData(aPayload);

                }

            break;

        case CHidTransport::EHidChannelCtrl:

            break;

        default:

            break;

        }

    return err;

    }

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

// CHidKeyboardDriver::CommandResult

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

//

void CHidKeyboardDriver::CommandResult(TInt /*aCmdAck*/)

    {

    // No implementation as we don't issue any requests to be acknowledged

    }

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

// CHidKeyboardDriver::Disconnected

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

//

void CHidKeyboardDriver::Disconnected(TInt aReason)

    {

    RDebug::Print(_L("CHidKeyboardDriver::Disconnected(%d)"), aReason);

    Stop();

    }

void CHidKeyboardDriver::UpdateXY(TInt aFieldIndex, const TDesC8& aReport)

    {

    //    DBG(RDebug::Print(_L("[HID]\tCHidMouseDriver::UpdateModifiers()")));

    // Translate the HID usage values into a boot protocol style

    // modifier bitmask:

    //

    TReportTranslator report(aReport, iMouseField[aFieldIndex]);

    TInt Xvalue = 0;

    TInt Yvalue = 0;

    TInt errX = report.GetValue(Xvalue, EGenericDesktopUsageX);

    TInt errY = report.GetValue(Yvalue, EGenericDesktopUsageY);

    DBG(RDebug::Print(_L("[HID]\tCHidMouseDriver::UpdateXY (%d,%d)"), Xvalue, Yvalue));

    if ((Xvalue != 0) || (Yvalue != 0))

        {

        MoveCursor(TPoint(Xvalue, Yvalue));

        }

    }

void CHidKeyboardDriver::UpdateWheel(TInt aFieldIndex, const TDesC8& aReport)

    {

    TReportTranslator report(aReport, iMouseField[aFieldIndex]);

    TInt Yvalue = 0;

    TInt errY = report.GetValue(Yvalue, EGenericDesktopUsageWheel);

    DBG(RDebug::Print(_L("[HID]\tCHidMouseDriver::UpdateWheel (%d)"), Yvalue));

    TInt absValue(Abs(Yvalue));

    if ((errY == KErrNone) && (absValue >= 1))

        {

        TRawEvent rawEvent;

        for (TInt ii = 0; ii < absValue; ii++)

            {

            rawEvent.Set(TRawEvent::EKeyDown,

                    (Yvalue > 0) ? EStdKeyUpArrow : EStdKeyDownArrow);

            UserSvr::AddEvent(rawEvent);

            rawEvent.Set(TRawEvent::EKeyUp,

                    (Yvalue > 0) ? EStdKeyUpArrow : EStdKeyDownArrow);

            UserSvr::AddEvent(rawEvent);

            }

        }

    DBG(RDebug::Print(_L("[HID]\t  new iModifiers = %02x"), iModifiers));

    }

void CHidKeyboardDriver::UpdateButtons(TInt aFieldIndex,

        const TDesC8& aReport)

    {

    DBG(RDebug::Print(_L("[HID]\tCHidMouseDriver::UpdateButtons()")));

    // Translate the HID usage values into a boot protocol style

    // modifier bitmask:

    //

    const TInt KButton1 = 1;

    const TInt KButton2 = 2;

    const TInt KButton3 = 3;

    TBool buttonPressed(EFalse);

    DBG(RDebug::Print(_L("[HID]\tCHidMouseDriver::UpdateButtons() %d, %d, %d"),

                    iMouseField[aFieldIndex]->UsagePage(),

                    iMouseField[aFieldIndex]->UsageMin(),

                    iMouseField[aFieldIndex]->UsageMax()));

    (void) aFieldIndex;

    // Hack but works

    // We dont come here if the report is wrong?

    TInt buttonByte = aReport[1];

    if (KButton1 == buttonByte)

        {

        DBG(RDebug::Print(_L("[HID]\tCHidMouseDriver::UpdateButtons() Button1")));

        buttonPressed = ETrue;

        }

    if (KButton2 == buttonByte)

        {

        DBG(RDebug::Print(_L("[HID]\tCHidMouseDriver::UpdateButtons() Button2")));

        if (!iButton2Down)

            {

            iButton2Down = ETrue;

            TRawEvent rawEvent;

            rawEvent.Set(TRawEvent::EKeyDown, EStdKeyApplication0);

            UserSvr::AddEvent(rawEvent);

            }

        }

    else

        {

        if (iButton2Down)

            {

            iButton2Down = EFalse;

            TRawEvent rawEvent;

            rawEvent.Set(TRawEvent::EKeyUp, EStdKeyApplication0);

            UserSvr::AddEvent(rawEvent);

            }

        }

    if (KButton3 == buttonByte)

        {

        DBG(RDebug::Print(_L("[HID]\tCHidMouseDriver::UpdateButtons() Button3")));

        buttonPressed = ETrue;

        }

    if (buttonPressed)

        {

        if (!iButtonDown)

            {

            iButtonDown = ETrue;

            SendButtonEvent(ETrue);//Send Mouse Button Down

            }

        }

    else

        {

        if (iButtonDown)

            {

            iButtonDown = EFalse;

            SendButtonEvent(EFalse); //Send Mouse Button Up

            }

        }

    }

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

// CHidKeyboardDriver::InterruptData

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

//

void CHidKeyboardDriver::InterruptData(const TDesC8& aPayload)

    {

    // If the report has a report ID, it is in the first byte.

    // If not, this value is ignored (see CField::IsInReport()).

    //

    TInt firstByte = aPayload[0];

        TRACE_INFO( (

                        _L("[HID]\tCHidKeyboardDriver::InterruptData(), report %d, length %d"),

                        firstByte, aPayload.Length()));

#ifdef _DEBUG

    for (TInt ii = 0; ii < aPayload.Length(); ii++)

        {

        TInt nextByte = aPayload[ii];

        DBG(RDebug::Print(

                        _L("[HID]\tCHidKeyboardDriver::InterruptData()  report[%d] =  %d"),

                        ii, nextByte));

        }

#endif

    TBool mouseEvent(EFalse);

    if (iMouseField[EMouseXY] && iMouseField[EMouseXY]->IsInReport(firstByte))

        {