1397 // EModifierRightFunc | EModifierFunc // 0x3000 (report bit 7) |
1445 // EModifierRightFunc | EModifierFunc // 0x3000 (report bit 7) |
1398 // }; |
1446 // }; |
1399 //---------------------------------------------------------------------------- |
1447 //---------------------------------------------------------------------------- |
1400 // |
1448 // |
1401 |
1449 |
1402 TBool CHidKeyboardDriver::HandleMultimediaKeys(TUint16 aScancodeKey, |
1450 TBool CHidKeyboardDriver::HandleKeyMapping(TDecodedKeyInfo& aKey, |
1403 TBool aIsKeyDown, TUint8 aHIDModifiers) |
1451 TBool aIsKeyDown, |
1404 { |
1452 TUint8 aHIDModifiers) |
1405 TBool ret = HandleMultimediaKeysForNokia(aScancodeKey, aIsKeyDown, |
1453 { |
1406 aHIDModifiers); |
1454 TRACE_INFO( (_L("[HID]\tCHidKeyboardDriver::HandleKeyMapping"))); |
1407 |
1455 |
1408 if (!ret) |
1456 TBool ret = EFalse; |
1409 { |
1457 |
1410 ret = HandleMultimediaKeysForStandard(aScancodeKey, aIsKeyDown, |
1458 switch (aKey.iScanCode) |
1411 aHIDModifiers); |
1459 { |
1412 } |
1460 case EStdKeyUpArrow: |
|
1461 { |
|
1462 ret = HandleKeyMappingUp(aKey, aIsKeyDown, aHIDModifiers); |
|
1463 break; |
|
1464 } |
|
1465 case EStdKeyDownArrow: |
|
1466 { |
|
1467 ret = HandleKeyMappingDown(aKey, aIsKeyDown, aHIDModifiers); |
|
1468 break; |
|
1469 } |
|
1470 case EStdKeyLeftArrow: |
|
1471 { |
|
1472 ret = HandleKeyMappingLeft(aKey, aIsKeyDown, aHIDModifiers); |
|
1473 break; |
|
1474 } |
|
1475 case EStdKeyRightArrow: |
|
1476 { |
|
1477 ret = HandleKeyMappingRight(aKey, aIsKeyDown, aHIDModifiers); |
|
1478 break; |
|
1479 } |
|
1480 case EStdKeyEscape: |
|
1481 // fall through |
|
1482 case EStdKeyF8: |
|
1483 // fall through |
|
1484 case EStdKeyApplication0: |
|
1485 // fall through |
|
1486 case EStdKeyApplication2: |
|
1487 // fall through |
|
1488 case EStdKeyApplication3: |
|
1489 // fall through |
|
1490 case EStdKeyF9: |
|
1491 // break; |
|
1492 case EStdKeyApplication4: |
|
1493 // fall through |
|
1494 case EStdKeyF7: |
|
1495 // fall through |
|
1496 case EStdKeyApplication5: |
|
1497 // fall through |
|
1498 case EStdKeyF12: |
|
1499 // fall through |
|
1500 case EStdKeyIncVolume: |
|
1501 // fall through |
|
1502 case EStdKeyF11: |
|
1503 // fall through |
|
1504 case EStdKeyDecVolume: |
|
1505 // fall through |
|
1506 case EStdKeyF10: |
|
1507 { |
|
1508 ret = HandleKeyMappingOther(aKey, aIsKeyDown, aHIDModifiers); |
|
1509 break; |
|
1510 } |
|
1511 default: |
|
1512 { |
|
1513 // no actions for these keys |
|
1514 break; |
|
1515 } |
|
1516 } |
|
1517 |
1413 return ret; |
1518 return ret; |
1414 } |
1519 } |
1415 |
1520 |
1416 void CHidKeyboardDriver::ResetBitmap(TBool aIsKeyDown, |
1521 // ---------------------------------------------------------------------- |
1417 TMmKeyDown aBitmapToReset) |
1522 // CHidKeyboardDriver::HandleKeyMappingUp |
1418 { |
1523 // Handle key mapping gor UP + MODIFIER |
1419 if (aIsKeyDown) |
1524 // ---------------------------------------------------------------------- |
1420 { |
1525 // |
1421 iMmKeyDown = (iMmKeyDown | aBitmapToReset); |
1526 TBool CHidKeyboardDriver::HandleKeyMappingUp(TDecodedKeyInfo& aKey, |
1422 } |
1527 TBool aIsKeyDown, |
1423 else |
1528 TUint8 aHIDModifiers) |
1424 { |
1529 { |
1425 iMmKeyDown = (iMmKeyDown & !aBitmapToReset); |
1530 TRACE_INFO((_L("[HID]\tCHidKeyboardDriver::HandleKeyMappingUp"))); |
1426 } |
1531 |
1427 } |
1532 TBool ret = EFalse; |
1428 |
|
1429 TBool CHidKeyboardDriver::HandleMultimediaKeysForNokia(TUint16 aScancodeKey, |
|
1430 TBool aIsKeyDown, TUint8 aHIDModifiers) |
|
1431 { |
|
1432 const TUint KHidModifierCtrl = 0x01; |
|
1433 const TUint KHidModifierCtrlRight = 0x10; |
|
1434 const TUint KHidModifierAlt = 0x04; |
|
1435 |
|
1436 // const TUint KHidModifierAltGr = 0x64; |
|
1437 TInt scancode = 0; |
1533 TInt scancode = 0; |
1438 TUint modifier = 0; |
1534 TUint modifier = 0; |
1439 TBool isMmKey = EFalse; |
1535 TBool isMmKey = EFalse; |
1440 |
1536 TMmKeyDown bitmapToReset = ENone; |
1441 TMmKeyDown bitmapToReset; |
1537 |
1442 |
1538 switch (aKey.iScanCode) |
1443 TRACE_INFO( (_L("[HID]\tCHidKeyboardDriver::HandleNokiaMultimediaKeys: scancode 0x%08x, HIDmodifiers 0x%08x"), aScancodeKey, aHIDModifiers)); |
1539 { |
1444 |
|
1445 switch (aScancodeKey) |
|
1446 { |
|
1447 |
|
1448 // Mappings for Nokia SU-8W |
|
1449 // Key down events are stored into bitmap in order to detect if keys are released in reverse order, which caused jamming. |
|
1450 // For example: control key released before arrow key. |
|
1451 |
|
1452 case EStdKeyUpArrow: |
1540 case EStdKeyUpArrow: |
1453 { |
1541 { |
1454 if (aHIDModifiers & (KHidModifierCtrl | KHidModifierCtrlRight) |
1542 // Key up and send key was emulated |
1455 || iMmKeyDown & EVolUp) |
1543 if (!aIsKeyDown && |
1456 { |
1544 iNavKeyDown & ESend) |
1457 scancode = EStdKeyIncVolume; //Volume Up = Ctrl + ArrowUp |
1545 { |
1458 isMmKey = ETrue; |
1546 TRACE_INFO((_L("[HID]\tCTRL + UP >>> SEND KEY UP"))); |
1459 // Set or reset flag bit |
1547 |
1460 |
1548 aKey.iScanCode = EStdKeyYes; |
1461 bitmapToReset = EVolUp; |
1549 TTranslatedKey& key = aKey.iEvent[0]; |
1462 TRACE_INFO( (_L("[HID]\tCHidKeyboardDriver::HandleNokiaMultimediaKeys: Volume up %d"), aIsKeyDown)); |
1550 key.iIsRepeatingKey = aIsKeyDown; |
1463 } |
1551 key.iScanCode = EStdKeyYes; |
1464 break; |
1552 key.iUnicode = EKeyYes; |
1465 } |
1553 |
1466 |
1554 iNavKeyDown = (iNavKeyDown & !ESend); |
1467 case EStdKeyDownArrow: |
1555 } |
1468 { |
1556 |
1469 if (aHIDModifiers & (KHidModifierCtrl | KHidModifierCtrlRight) |
1557 //CTRL = Send key |
1470 || iMmKeyDown & EVolDown) |
1558 else if (aIsKeyDown && |
1471 { |
1559 aHIDModifiers & (KHidModifierCtrl | KHidModifierCtrlRight)) |
1472 scancode = EStdKeyDecVolume; //Volume Down = Ctrl + ArrowDown |
1560 { |
1473 isMmKey = ETrue; |
1561 TRACE_INFO((_L("[HID]\tCTRL + UP >>> SEND KEY DOWN"))); |
1474 bitmapToReset = EVolDown; |
1562 |
1475 TRACE_INFO( (_L("[HID]\tCHidKeyboardDriver::HandleNokiaMultimediaKeys: Volume down %d"), aIsKeyDown)); |
1563 aKey.iScanCode = EStdKeyYes; |
1476 } |
1564 aKey.iCount = 1; |
1477 break; |
1565 TTranslatedKey& key = aKey.iEvent[0]; |
1478 } |
1566 key.iIsRepeatingKey = aIsKeyDown; |
1479 |
1567 key.iScanCode = EStdKeyYes; |
1480 case EStdKeyRightArrow: |
1568 key.iUnicode = EKeyYes; |
1481 { |
1569 |
1482 if (aHIDModifiers & KHidModifierAlt || iMmKeyDown & EPlay) |
1570 iNavKeyDown = (iNavKeyDown | ESend); |
1483 { |
1571 } |
1484 scancode = EStdKeyApplication2; //Play = Alt + ArrowRight |
1572 |
1485 isMmKey = ETrue; |
1573 //ALT = Stop |
1486 bitmapToReset = EPlay; |
1574 else if (aHIDModifiers & (KHidModifierAlt | KHidModifierAltRight) || |
1487 |
1575 iMmKeyDown & EStop) |
1488 TRACE_INFO( (_L("[HID]\tCHidKeyboardDriver::HandleNokiaMultimediaKeys: Play %d"), aIsKeyDown)); |
1576 { |
1489 } |
1577 TRACE_INFO((_L("[HID]\tALT + UP >>> STOP"))); |
1490 else if (aHIDModifiers & (KHidModifierCtrl |
1578 |
1491 | KHidModifierCtrlRight) || iMmKeyDown & ENext) |
1579 scancode = EStdKeyApplication3; |
1492 { |
|
1493 scancode = EStdKeyApplication4; //Next = Ctrl + ArrowRight |
|
1494 isMmKey = ETrue; |
|
1495 bitmapToReset = ENext; |
|
1496 TRACE_INFO( (_L("[HID]\tCHidKeyboardDriver::HandleNokiaMultimediaKeys: Next %d"), aIsKeyDown)); |
|
1497 } |
|
1498 break; |
|
1499 } |
|
1500 |
|
1501 case EStdKeyLeftArrow: |
|
1502 { |
|
1503 if (aHIDModifiers & KHidModifierAlt || iMmKeyDown & EStop) |
|
1504 { |
|
1505 scancode = EStdKeyApplication3; //Stop = Alt + ArrowLeft |
|
1506 isMmKey = ETrue; |
1580 isMmKey = ETrue; |
1507 bitmapToReset = EStop; |
1581 bitmapToReset = EStop; |
1508 TRACE_INFO( (_L("[HID]\tCHidKeyboardDriver::HandleNokiaMultimediaKeys: Stop %d"), aIsKeyDown)); |
1582 } |
1509 } |
1583 |
1510 else if (aHIDModifiers & (KHidModifierCtrl |
1584 //SHIFT = Volume up |
1511 | KHidModifierCtrlRight) || iMmKeyDown & EPrev) |
1585 else if (aHIDModifiers & (KHidModifierShift | KHidModifierShiftRight) || |
1512 { |
1586 iMmKeyDown & EVolUp) |
1513 scancode = EStdKeyApplication5; //Prev = Ctrl + ArrowLeft |
1587 { |
|
1588 TRACE_INFO((_L("[HID]\tSHIFT + UP >>> VOLUME UP"))); |
|
1589 |
|
1590 scancode = EStdKeyIncVolume; |
1514 isMmKey = ETrue; |
1591 isMmKey = ETrue; |
1515 bitmapToReset = EPrev; |
1592 bitmapToReset = EVolUp; |
1516 TRACE_INFO( (_L("[HID]\tCHidKeyboardDriver::HandleNokiaMultimediaKeys: Prev %d"), aIsKeyDown)); |
1593 } |
1517 } |
1594 break; |
1518 break; |
1595 } |
1519 } |
|
1520 |
|
1521 default: |
1596 default: |
1522 break; |
1597 { |
|
1598 // no actions |
|
1599 break; |
|
1600 } |
1523 } |
1601 } |
1524 |
1602 |
1525 if (isMmKey) |
1603 if (isMmKey) |
1526 { |
1604 { |
1527 ResetBitmap(aIsKeyDown, bitmapToReset); |
1605 if (bitmapToReset) |
|
1606 { |
|
1607 ResetBitmap(aIsKeyDown, bitmapToReset); |
|
1608 } |
1528 SendRawEvent(scancode, aIsKeyDown, modifier); |
1609 SendRawEvent(scancode, aIsKeyDown, modifier); |
1529 } |
1610 ret = ETrue; |
1530 return isMmKey; |
1611 } |
1531 } |
1612 |
1532 |
1613 return ret; |
1533 TBool CHidKeyboardDriver::HandleMultimediaKeysForStandard( |
1614 } |
1534 TUint16 aScancodeKey, TBool aIsKeyDown, TUint8 aHIDModifiers) |
1615 |
1535 { |
1616 // ---------------------------------------------------------------------- |
|
1617 // CHidKeyboardDriver::HandleKeyMappingDown |
|
1618 // Handle key mapping gor DOWN + MODIFIER |
|
1619 // ---------------------------------------------------------------------- |
|
1620 // |
|
1621 TBool CHidKeyboardDriver::HandleKeyMappingDown(TDecodedKeyInfo& aKey, |
|
1622 TBool aIsKeyDown, |
|
1623 TUint8 aHIDModifiers) |
|
1624 { |
|
1625 TRACE_INFO((_L("[HID]\tCHidKeyboardDriver::HandleKeyMappingDown"))); |
|
1626 |
|
1627 TBool ret = EFalse; |
1536 TInt scancode = 0; |
1628 TInt scancode = 0; |
1537 TUint modifier = 0; |
1629 TUint modifier = 0; |
1538 TBool isMmKey = EFalse; |
1630 TBool isMmKey = EFalse; |
1539 |
1631 TMmKeyDown bitmapToReset = ENone; |
1540 TRACE_INFO( (_L("[HID]\tCHidKeyboardDriver::HandleNokiaMultimediaKeys: scancode 0x%08x, HIDmodifiers 0x%08x"), aScancodeKey, aHIDModifiers)); |
1632 |
1541 //please complier... |
1633 switch (aKey.iScanCode) |
1542 (void) aHIDModifiers; |
1634 { |
1543 |
1635 case EStdKeyDownArrow: |
1544 switch (aScancodeKey) |
1636 { |
1545 { |
1637 // Key up and end key was emulated |
1546 // Mappings for standard keyboards |
1638 if (!aIsKeyDown && |
1547 |
1639 iNavKeyDown & EEnd) |
1548 case EStdKeyApplication2: //Play |
1640 { |
1549 { |
1641 TRACE_INFO((_L("[HID]\tCTRL + DOWN >>> END KEY UP"))); |
|
1642 |
|
1643 aKey.iScanCode = EStdKeyNo; |
|
1644 TTranslatedKey& key = aKey.iEvent[0]; |
|
1645 key.iIsRepeatingKey = aIsKeyDown; |
|
1646 key.iScanCode = EStdKeyNo; |
|
1647 key.iUnicode = EKeyNo; |
|
1648 |
|
1649 iNavKeyDown = (iNavKeyDown & !EEnd); |
|
1650 } |
|
1651 |
|
1652 //CTRL = End key |
|
1653 else if (aIsKeyDown && |
|
1654 aHIDModifiers & (KHidModifierCtrl | KHidModifierCtrlRight)) |
|
1655 { |
|
1656 TRACE_INFO((_L("[HID]\tCTRL + DOWN >>> END KEY DOWN"))); |
|
1657 |
|
1658 aKey.iScanCode = EStdKeyNo; |
|
1659 aKey.iCount = 1; |
|
1660 TTranslatedKey& key = aKey.iEvent[0]; |
|
1661 key.iIsRepeatingKey = aIsKeyDown; |
|
1662 key.iScanCode = EStdKeyNo; |
|
1663 key.iUnicode = EKeyNo; |
|
1664 |
|
1665 iNavKeyDown = (iNavKeyDown | EEnd); |
|
1666 } |
|
1667 |
|
1668 //ALT = Stop |
|
1669 else if (aHIDModifiers & (KHidModifierAlt | KHidModifierAltRight) || |
|
1670 iMmKeyDown & EPlay) |
|
1671 { |
|
1672 TRACE_INFO((_L("[HID]\tALT + DOWN >>> PLAY / PAUSE"))); |
|
1673 |
|
1674 scancode = EStdKeyApplication2; |
|
1675 isMmKey = ETrue; |
|
1676 bitmapToReset = EPlay; |
|
1677 } |
|
1678 |
|
1679 //SHIFT = Volume down |
|
1680 else if (aHIDModifiers & (KHidModifierShift | KHidModifierShiftRight) || |
|
1681 iMmKeyDown & EVolDown) |
|
1682 { |
|
1683 TRACE_INFO((_L("[HID]\tSHIFT + DOWN >>> VOLUME DOWN"))); |
|
1684 |
|
1685 scancode = EStdKeyDecVolume; |
|
1686 isMmKey = ETrue; |
|
1687 bitmapToReset = EVolDown; |
|
1688 } |
|
1689 break; |
|
1690 } |
|
1691 default: |
|
1692 { |
|
1693 // no actions |
|
1694 break; |
|
1695 } |
|
1696 } |
|
1697 |
|
1698 if (isMmKey) |
|
1699 { |
|
1700 if (bitmapToReset) |
|
1701 { |
|
1702 ResetBitmap(aIsKeyDown, bitmapToReset); |
|
1703 } |
|
1704 SendRawEvent(scancode, aIsKeyDown, modifier); |
|
1705 ret = ETrue; |
|
1706 } |
|
1707 |
|
1708 return ret; |
|
1709 } |
|
1710 |
|
1711 // ---------------------------------------------------------------------- |
|
1712 // CHidKeyboardDriver::HandleKeyMappingLeft |
|
1713 // Handle key mapping gor LEFT + MODIFIER |
|
1714 // ---------------------------------------------------------------------- |
|
1715 // |
|
1716 TBool CHidKeyboardDriver::HandleKeyMappingLeft(TDecodedKeyInfo& aKey, |
|
1717 TBool aIsKeyDown, |
|
1718 TUint8 aHIDModifiers) |
|
1719 { |
|
1720 TRACE_INFO((_L("[HID]\tCHidKeyboardDriver::HandleKeyMappingLeft"))); |
|
1721 |
|
1722 TBool ret = EFalse; |
|
1723 TInt scancode = 0; |
|
1724 TUint modifier = 0; |
|
1725 TBool isMmKey = EFalse; |
|
1726 TMmKeyDown bitmapToReset = ENone; |
|
1727 |
|
1728 switch (aKey.iScanCode) |
|
1729 { |
|
1730 case EStdKeyLeftArrow: |
|
1731 { |
|
1732 // Key up and LSK was simulated |
|
1733 if (!aIsKeyDown && |
|
1734 iNavKeyDown & ELsk) |
|
1735 { |
|
1736 TRACE_INFO((_L("[HID]\tCTRL + LEFT >>> LEFT SOFTKEY UP"))); |
|
1737 |
|
1738 aKey.iScanCode = EStdKeyDevice0; |
|
1739 TTranslatedKey& key = aKey.iEvent[0]; |
|
1740 key.iIsRepeatingKey = aIsKeyDown; |
|
1741 key.iScanCode = EStdKeyDevice0; |
|
1742 key.iUnicode = EKeyDevice0; |
|
1743 |
|
1744 iNavKeyDown = (iNavKeyDown & !ELsk); |
|
1745 } |
|
1746 |
|
1747 //CTRL = LSK |
|
1748 else if (aIsKeyDown && |
|
1749 aHIDModifiers & (KHidModifierCtrl | KHidModifierCtrlRight)) |
|
1750 { |
|
1751 TRACE_INFO((_L("[HID]\tCTRL + LEFT >>> LEFT SOFTKEY DOWN"))); |
|
1752 |
|
1753 aKey.iScanCode = EStdKeyDevice0; |
|
1754 aKey.iCount = 1; |
|
1755 TTranslatedKey& key = aKey.iEvent[0]; |
|
1756 key.iIsRepeatingKey = aIsKeyDown; |
|
1757 key.iScanCode = EStdKeyDevice0; |
|
1758 key.iUnicode = EKeyDevice0; |
|
1759 |
|
1760 iNavKeyDown = (iNavKeyDown | ELsk); |
|
1761 } |
|
1762 |
|
1763 //ALT (short) = Previous |
|
1764 //ALT (long) = Backwards |
|
1765 else if (aHIDModifiers & (KHidModifierAlt | KHidModifierAltRight) || |
|
1766 iMmKeyDown & EPrev) |
|
1767 { |
|
1768 TRACE_INFO((_L("[HID]\tALT + LEFT >>> PREVIOUS / REW"))); |
|
1769 |
|
1770 scancode = EStdKeyApplication5; |
|
1771 isMmKey = ETrue; |
|
1772 bitmapToReset = ENext; |
|
1773 } |
|
1774 |
|
1775 //SHIFT = Mute toggle |
|
1776 else if (aHIDModifiers & (KHidModifierShift | KHidModifierShiftRight) || |
|
1777 iMmKeyDown & EPlay) |
|
1778 { |
|
1779 TRACE_INFO((_L("[HID]\tSHIFT + LEFT >>> MUTE / UNMUTE"))); |
|
1780 |
|
1781 scancode = EStdKeyApplication2; |
|
1782 isMmKey = ETrue; |
|
1783 bitmapToReset = EPlay; |
|
1784 } |
|
1785 break; |
|
1786 } |
|
1787 default: |
|
1788 { |
|
1789 // no actions |
|
1790 break; |
|
1791 } |
|
1792 } |
|
1793 |
|
1794 if (isMmKey) |
|
1795 { |
|
1796 if (bitmapToReset) |
|
1797 { |
|
1798 ResetBitmap(aIsKeyDown, bitmapToReset); |
|
1799 } |
|
1800 SendRawEvent(scancode, aIsKeyDown, modifier); |
|
1801 ret = ETrue; |
|
1802 } |
|
1803 |
|
1804 return ret; |
|
1805 } |
|
1806 |
|
1807 // ---------------------------------------------------------------------- |
|
1808 // CHidKeyboardDriver::HandleKeyMappingRight |
|
1809 // Handle key mapping gor RIGHT + MODIFIER |
|
1810 // ---------------------------------------------------------------------- |
|
1811 // |
|
1812 TBool CHidKeyboardDriver::HandleKeyMappingRight(TDecodedKeyInfo& aKey, |
|
1813 TBool aIsKeyDown, |
|
1814 TUint8 aHIDModifiers) |
|
1815 { |
|
1816 TRACE_INFO((_L("[HID]\tCHidKeyboardDriver::HandleKeyMappingRight"))); |
|
1817 |
|
1818 TBool ret = EFalse; |
|
1819 TInt scancode = 0; |
|
1820 TUint modifier = 0; |
|
1821 TBool isMmKey = EFalse; |
|
1822 TMmKeyDown bitmapToReset = ENone; |
|
1823 |
|
1824 switch (aKey.iScanCode) |
|
1825 { |
|
1826 case EStdKeyRightArrow: |
|
1827 { |
|
1828 // Key up and RSK was simulated |
|
1829 if (!aIsKeyDown && |
|
1830 iNavKeyDown & ERsk) |
|
1831 { |
|
1832 TRACE_INFO((_L("[HID]\tCTRL + LEFT >>> RIGHT SOFTKEY UP"))); |
|
1833 |
|
1834 aKey.iScanCode = EStdKeyDevice1; |
|
1835 TTranslatedKey& key = aKey.iEvent[0]; |
|
1836 key.iIsRepeatingKey = aIsKeyDown; |
|
1837 key.iScanCode = EStdKeyDevice1; |
|
1838 key.iUnicode = EKeyDevice1; |
|
1839 |
|
1840 iNavKeyDown = (iNavKeyDown & !ERsk); |
|
1841 } |
|
1842 |
|
1843 //CTRL = RSK |
|
1844 else if (aIsKeyDown && |
|
1845 aHIDModifiers & (KHidModifierCtrl | KHidModifierCtrlRight)) |
|
1846 { |
|
1847 TRACE_INFO((_L("[HID]\tCTRL + RIGHT >>> RIGHT SOFTKEY DOWN"))); |
|
1848 |
|
1849 aKey.iScanCode = EStdKeyDevice1; |
|
1850 aKey.iCount = 1; |
|
1851 TTranslatedKey& key = aKey.iEvent[0]; |
|
1852 key.iIsRepeatingKey = aIsKeyDown; |
|
1853 key.iScanCode = EStdKeyDevice1; |
|
1854 key.iUnicode = EKeyDevice1; |
|
1855 |
|
1856 iNavKeyDown = (iNavKeyDown | ERsk); |
|
1857 } |
|
1858 |
|
1859 //ALT (short) = Next |
|
1860 //ALT (long) = Forward |
|
1861 else if (aHIDModifiers & (KHidModifierAlt | KHidModifierAltRight) || |
|
1862 iMmKeyDown & EPrev) |
|
1863 { |
|
1864 TRACE_INFO((_L("[HID]\tALT + RIGHT >>> NEXT / FF"))); |
|
1865 |
|
1866 scancode = EStdKeyApplication4; |
|
1867 isMmKey = ETrue; |
|
1868 bitmapToReset = EPrev; |
|
1869 } |
|
1870 |
|
1871 //SHIFT = Mute toggle (currently just toggle play / pause) |
|
1872 else if (aHIDModifiers & (KHidModifierShift | KHidModifierShiftRight) || |
|
1873 iMmKeyDown & EPlay) |
|
1874 { |
|
1875 TRACE_INFO((_L("[HID]\tSHIFT + RIGHT >>> MUTE / UNMUTE"))); |
|
1876 |
|
1877 scancode = EStdKeyApplication2; |
|
1878 isMmKey = ETrue; |
|
1879 bitmapToReset = EPlay; |
|
1880 } |
|
1881 break; |
|
1882 } |
|
1883 default: |
|
1884 { |
|
1885 // no actions |
|
1886 break; |
|
1887 } |
|
1888 } |
|
1889 |
|
1890 if (isMmKey) |
|
1891 { |
|
1892 if (bitmapToReset) |
|
1893 { |
|
1894 ResetBitmap(aIsKeyDown, bitmapToReset); |
|
1895 } |
|
1896 SendRawEvent(scancode, aIsKeyDown, modifier); |
|
1897 ret = ETrue; |
|
1898 } |
|
1899 |
|
1900 return ret; |
|
1901 } |
|
1902 |
|
1903 // ---------------------------------------------------------------------- |
|
1904 // CHidKeyboardDriver::HandleKeyMappingOther |
|
1905 // Handle key mapping gor OTHER + MODIFIER |
|
1906 // ---------------------------------------------------------------------- |
|
1907 // |
|
1908 TBool CHidKeyboardDriver::HandleKeyMappingOther(TDecodedKeyInfo& aKey, |
|
1909 TBool aIsKeyDown, |
|
1910 TUint8 /*aHIDModifiers*/) |
|
1911 { |
|
1912 TRACE_INFO((_L("[HID]\tCHidKeyboardDriver::HandleKeyMappingOther"))); |
|
1913 |
|
1914 TBool ret = EFalse; |
|
1915 TInt scancode = 0; |
|
1916 TUint modifier = 0; |
|
1917 TBool isMmKey = EFalse; |
|
1918 |
|
1919 switch (aKey.iScanCode) |
|
1920 { |
|
1921 case EStdKeyEscape: |
|
1922 { |
|
1923 // ESC is released and keys were locked, eat the key press |
|
1924 if (!aIsKeyDown && |
|
1925 iNavKeyDown & EEsc) |
|
1926 { |
|
1927 TRACE_INFO((_L("[HID]\tESC >>> DISBALE KEY LOCK UP"))); |
|
1928 |
|
1929 ret = ETrue; |
|
1930 iNavKeyDown = (iNavKeyDown & !EEsc); |
|
1931 } |
|
1932 |
|
1933 // ESC when keylock enabled >>> Disabled key lock |
|
1934 else if (aIsKeyDown && |
|
1935 iKeyLock.IsKeyLockEnabled()) |
|
1936 { |
|
1937 TInt devLockStatus( EAutolockStatusUninitialized ); |
|
1938 TInt err = RProperty::Get( KPSUidCoreApplicationUIs, KCoreAppUIsAutolockStatus, devLockStatus ); |
|
1939 |
|
1940 if (!err) |
|
1941 { |
|
1942 if (EAutolockOff == devLockStatus || EAutolockStatusUninitialized == devLockStatus) |
|
1943 { |
|
1944 TRACE_INFO((_L("[HID]\tESC >>> AUTO LOCK IS OFF, DISBALE KEY LOCK DOWN "))); |
|
1945 iKeyLock.DisableKeyLock(); |
|
1946 ret = ETrue; |
|
1947 iNavKeyDown = (iNavKeyDown | EEsc); |
|
1948 } |
|
1949 else |
|
1950 { |
|
1951 TRACE_INFO((_L("[HID]\tESC >>> AUTO LOCK IS ON, DISBALE KEY LOCK DOWN SKIPPED"))); |
|
1952 } |
|
1953 } |
|
1954 else |
|
1955 { |
|
1956 TRACE_INFO((_L("[HID]\tESC >>> FAILED to get AUTO LOCK status, DISBALE KEY LOCK DOWN SKIPPED"))); |
|
1957 } |
|
1958 |
|
1959 } |
|
1960 |
|
1961 break; |
|
1962 } |
|
1963 case EStdKeyApplication0: |
|
1964 { |
|
1965 TRACE_INFO((_L("[HID]\tAPPLICATION KEY(Alt+Tab) >>> TSW"))); |
|
1966 |
|
1967 // Dedicated Application key |
|
1968 scancode = EStdKeyApplication0; |
|
1969 isMmKey = ETrue; |
|
1970 break; |
|
1971 } |
|
1972 case EStdKeyF8: |
|
1973 // fall through |
|
1974 case EStdKeyApplication2: |
|
1975 { |
|
1976 TRACE_INFO((_L("[HID]\tF8 / APPLICATION2 >>> PLAY / PAUSE"))); |
|
1977 |
|
1978 // PLAY / PAUSE |
|
1979 if (aKey.iScanCode != EStdKeyApplication2) |
|
1980 { |
|
1981 scancode = EStdKeyApplication2; |
|
1982 isMmKey = ETrue; |
|
1983 } |
|
1984 break; |
|
1985 } |
|
1986 case EStdKeyApplication3: |
|
1987 { |
|
1988 TRACE_INFO((_L("[HID]\tAPPLICATION3 >>> STOP"))); |
|
1989 |
|
1990 // STOP |
|
1991 scancode = EStdKeyApplication3; |
|
1992 isMmKey = ETrue; |
|
1993 break; |
|
1994 } |
|
1995 case EStdKeyF9: |
|
1996 // break; |
|
1997 case EStdKeyApplication4: |
|
1998 { |
|
1999 TRACE_INFO((_L("[HID]\tF9 / APPLICATION4 >>> NEXT / FF"))); |
|
2000 |
|
2001 // NEXT |
|
2002 scancode = EStdKeyApplication4; |
|
2003 isMmKey = ETrue; |
|
2004 break; |
|
2005 } |
|
2006 case EStdKeyF7: |
|
2007 // fall through |
|
2008 case EStdKeyApplication5: |
|
2009 { |
|
2010 TRACE_INFO((_L("[HID]\tF7 / APPLICATION5 >>> PREVIOUS / REW"))); |
|
2011 |
|
2012 // PREVIOUS |
|
2013 scancode = EStdKeyApplication5; |
|
2014 isMmKey = ETrue; |
|
2015 break; |
|
2016 } |
|
2017 case EStdKeyF12: |
|
2018 // fall through |
|
2019 case EStdKeyIncVolume: |
|
2020 { |
|
2021 TRACE_INFO((_L("[HID]\tF12 / INCVOLUME >>> VOLUME UP"))); |
|
2022 |
|
2023 // VOLUME UP |
|
2024 scancode = EStdKeyIncVolume; |
|
2025 isMmKey = ETrue; |
|
2026 break; |
|
2027 } |
|
2028 case EStdKeyF11: |
|
2029 // fall through |
|
2030 case EStdKeyDecVolume: |
|
2031 { |
|
2032 TRACE_INFO((_L("[HID]\tF11 / DECVOLUME >>> VOLUME DOWN"))); |
|
2033 |
|
2034 // VOLUME DOWN |
|
2035 scancode = EStdKeyDecVolume; |
|
2036 isMmKey = ETrue; |
|
2037 break; |
|
2038 } |
|
2039 case EStdKeyF10: |
|
2040 { |
|
2041 TRACE_INFO((_L("[HID]\tF10 >>> MUTE"))); |
|
2042 |
|
2043 // MUTE (currently just toggle play / pause) |
1550 scancode = EStdKeyApplication2; |
2044 scancode = EStdKeyApplication2; |
1551 isMmKey = ETrue; |
2045 isMmKey = ETrue; |
1552 TRACE_INFO( (_L("[HID]\tCHidKeyboardDriver::HandleNokiaMultimediaKeys: Play %d"), aIsKeyDown)); |
2046 break; |
1553 break; |
2047 } |
1554 } |
|
1555 |
|
1556 case EStdKeyApplication3: //Stop |
|
1557 { |
|
1558 scancode = EStdKeyApplication3; |
|
1559 isMmKey = ETrue; |
|
1560 TRACE_INFO( (_L("[HID]\tCHidKeyboardDriver::HandleNokiaMultimediaKeys: Stop %d"), aIsKeyDown)); |
|
1561 break; |
|
1562 } |
|
1563 |
|
1564 case EStdKeyApplication4: //Next |
|
1565 { |
|
1566 scancode = EStdKeyApplication4; |
|
1567 isMmKey = ETrue; |
|
1568 TRACE_INFO( (_L("[HID]\tCHidKeyboardDriver::HandleNokiaMultimediaKeys: Next %d"), aIsKeyDown)); |
|
1569 break; |
|
1570 } |
|
1571 |
|
1572 case EStdKeyApplication5: //Prev |
|
1573 { |
|
1574 scancode = EStdKeyApplication5; |
|
1575 isMmKey = ETrue; |
|
1576 TRACE_INFO( (_L("[HID]\tCHidKeyboardDriver::HandleNokiaMultimediaKeys: Prev %d"), aIsKeyDown)); |
|
1577 break; |
|
1578 } |
|
1579 |
|
1580 case EStdKeyIncVolume: //Volume up |
|
1581 { |
|
1582 scancode = EStdKeyIncVolume; |
|
1583 isMmKey = ETrue; |
|
1584 TRACE_INFO( (_L("[HID]\tCHidKeyboardDriver::HandleNokiaMultimediaKeys: Volume up %d"), aIsKeyDown)); |
|
1585 break; |
|
1586 } |
|
1587 |
|
1588 case EStdKeyDecVolume: //Volume down |
|
1589 { |
|
1590 scancode = EStdKeyDecVolume; |
|
1591 isMmKey = ETrue; |
|
1592 TRACE_INFO( (_L("[HID]\tCHidKeyboardDriver::HandleNokiaMultimediaKeys: Volume down %d"), aIsKeyDown)); |
|
1593 break; |
|
1594 } |
|
1595 |
|
1596 default: |
2048 default: |
1597 break; |
2049 { |
|
2050 break; |
|
2051 } |
1598 } |
2052 } |
1599 |
2053 |
1600 if (isMmKey) |
2054 if (isMmKey) |
1601 { |
2055 { |
1602 SendRawEvent(scancode, aIsKeyDown, modifier); |
2056 SendRawEvent(scancode, aIsKeyDown, modifier); |
1603 } |
2057 ret = ETrue; |
1604 return isMmKey; |
2058 } |
|
2059 |
|
2060 return ret; |
|
2061 } |
|
2062 |
|
2063 void CHidKeyboardDriver::ResetBitmap(TBool aIsKeyDown, |
|
2064 TMmKeyDown aBitmapToReset) |
|
2065 { |
|
2066 if (aIsKeyDown) |
|
2067 { |
|
2068 iMmKeyDown = (iMmKeyDown | aBitmapToReset); |
|
2069 } |
|
2070 else |
|
2071 { |
|
2072 iMmKeyDown = (iMmKeyDown & !aBitmapToReset); |
|
2073 } |
1605 } |
2074 } |
1606 |
2075 |
1607 // ---------------------------------------------------------------------- |
2076 // ---------------------------------------------------------------------- |
1608 // CHidKeyboardDriver::SendRawEvent |
2077 // CHidKeyboardDriver::SendRawEvent |
1609 // Send raw key event to window server |
2078 // Send raw key event to window server |