/*

* 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 <e32keys.h>

#include <avkondomainpskeys.h>

#include <coreapplicationuisdomainpskeys.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;

// The bitmap of modifier byte is defined in the HID spec.

// 8.3 Report Format for Array Items (HID1_11.pdf p56)

// 

// bit  description     mask

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

// 0    LEFT CTRL     = 0x01

// 1    LEFT SHIFT    = 0x02

// 2    LEFT ALT      = 0x04

// 3    LEFT GUI      = 0x08

// 4    RIGHT CTRL    = 0x10

// 5    RIGHT SHIFT   = 0x20

// 6    RIGHT ALT     = 0x40

// 7    RIGHT GUI     = 0x80

const TUint KHidModifierCtrl = 0x01;

const TUint KHidModifierCtrlRight = 0x10;

const TUint KHidModifierAlt = 0x04;

const TUint KHidModifierAltRight = 0x40;

const TUint KHidModifierShift = 0x02;

const TUint KHidModifierShiftRight = 0x20;

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

// 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();

    iSettings = CBtHidSettings::NewL();

    // create a keylock session

    TInt err = iKeyLock.Connect();

    TRACE_INFO( (_L("[HID]\tCHidKeyboardDriver::ConstructL: key lock err = %d"), err));

    User::LeaveIfError(err);    

    }

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

// 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();

        }

    if (iSettings)

        delete iSettings;

    iKeyLock.Close();

    }

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

// 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);

        }

    // Ready to process keyboard events:

    iDriverState = EInitialised;

    }

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

// 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();

    }

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

// 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)

                {

                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();

    }

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

// 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

    // First check for any rollover errors:

    //

    TInt i;

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

        {

        if (iField[i] && iField[i]->IsInReport(firstByte)

                && (iField[i]->UsagePage() == EUsagePageKeyboard))

            {

            if (IsRollover(i, aPayload))

                {

                CancelAllKeys();

                iLayoutMgr.Reset();

                return;

                }

            }

        }

    // Update the modifier state:

    //

    if (iField[EModifierKeys] && iField[EModifierKeys]->IsInReport(firstByte))

        {

        UpdateModifiers(EModifierKeys, aPayload);

        }

    // Finally, look for key events in all fields in this report:

    //

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

        {

        if (iField[i] && iField[i]->IsInReport(firstByte))

            {

            ProcessKeys(i, aPayload);

            }

        }

    }

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

// CHidKeyboardDriver::IsRollover

//

// IsRollover() checks to see if the keyboard is in a rollover state

// (where too many keys are pressed to be able to give a sensible

// report).

//

// Rollover can only happen for fields with usage page 0x07.

//

// Returns ETrue if the keyboard is in a rollover state

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

//

TBool CHidKeyboardDriver::IsRollover(TInt aFieldIndex, const TDesC8& aReport) const

    {

    TBool rollover = ETrue;

    TReportTranslator report(aReport, iField[aFieldIndex]);

    for (TInt i = 0; rollover && (i < report.Count()); ++i)

        {

        const TInt KRolloverError = 1;

        TInt usage;

        if (KErrNone == report.GetUsageId(usage, i) && usage

                != KRolloverError)

            {

            rollover = EFalse;

            }

        }

    return rollover;

    }

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

// CHidKeyboardDriver::ProcessKeys

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

//

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

    {

        TRACE_FUNC

    ((_L("[HID]\tCHidKeyboardDriver::ProcessKeys()")));

    // Get the appropriate field and key press array

    const CField* field = iField[aFieldIndex];

    RArray<TInt>& keysPressed = iKeys[aFieldIndex];

    TInt bufferSize = keysPressed.Count();

    TReportTranslator report(aReport, field);

        // 1. For each key that appeared in the last report but does

        //    not appear in this report, send a key UP event.

        TRACE_FUNC

    ((_L("[HID]\t  Testing for keys up")));

    TInt i;

    for (i = 0; i < bufferSize; ++i)

        {

        TInt key = keysPressed[i];

        if (key)

            {

            TInt pressed = EFalse;

            if ((report.GetValue(pressed, key) == KErrNone) && (!pressed))

                {

                    TRACE_INFO( (_L("[HID]\t  Key up: %d [0x%04x]"), key, key));

                KeyUp(key, field->UsagePage());

                }

            }

        }

        // 2. For each key that appears in this report, but does

        //    not appear in the last report, send a key DOWN event.

        TRACE_FUNC

    ((_L("  Testing for keys down")));

    for (i = 0; i < report.Count(); ++i)

        {

        TInt key;

        if ((KErrNone == report.GetUsageId(key, i)) && (key != 0))

            {

            // Was the key present (pressed) in the last report?

            TBool match = EFalse;

            for (TInt j = 0; !match && (j < bufferSize); ++j)

                {

                match = (key == keysPressed[j]);

                }

            // If it's a newly-pressed key then send a KeyDown

            if (!match)

                {

                    TRACE_INFO( (_L("[HID]\t  Key down: %d [0x%02x]"), key, key));

                if (iInputHandlingReg->AllowedToHandleEvent(

                        EUsagePageKeyboard, key))

                    {

                    iInputHandlingReg->AddHandledEvent(

                            EUsagePageGenericDesktop, key);

                    KeyDown(key, field->UsagePage());

                    UpdateLockState(key);

                    }

                }

            }

        }

    // 3. Finally, record what keys are down:

    TInt index = 0;

    for (i = 0; (i < report.Count()) && (index < bufferSize); ++i)

        {

        TInt key;

        if (KErrNone == report.GetUsageId(key, i) && key != 0)

            {

            keysPressed[index++] = key;

            }

        }

    while (index < bufferSize)

        {

        keysPressed[index++] = 0;

        }

    }

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

// CHidKeyboardDriver::KeyEvent

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

//

void CHidKeyboardDriver::KeyEvent(TBool aIsKeyDown, TInt aHidKey,

        TInt aUsagePage)

    {

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

                        aUsagePage, aHidKey));

    // Any type of key event will cancel a repeating key:

    //

    if (iRepeatTimer->IsActive())

        {

        iRepeatTimer->Cancel();

        }

    if (iRepeatEndTimer->IsActive())

        {

        iRepeatEndTimer->Cancel();

        }

    // Pass the key info to the keyboard layout translator:

    //

    TDecodedKeyInfo decodedKeys;

    TInt err = iLayoutMgr.KeyEvent(aIsKeyDown, aHidKey, aUsagePage,

            iModifiers, TLockKeys(iLockState & ECapsLock, iLockState

                    & ENumLock), decodedKeys);

    TTranslatedKey& key = decodedKeys.iEvent[0];

    if (err == KErrNone)

        {

        // Send the "key down" or "key up" event to the system:

        // Handle special application launch key combinations

        TRAPD( err, HandleApplicationLaunchKeysL(decodedKeys.iScanCode, aIsKeyDown, iModifiers));

        if (KErrNone != err)

            {