296 lines
15 KiB
Python
296 lines
15 KiB
Python
## Copyright (C) 2024 Solaar Contributors https://pwr-solaar.github.io/Solaar/
|
|
##
|
|
## This program is free software; you can redistribute it and/or modify
|
|
## it under the terms of the GNU General Public License as published by
|
|
## the Free Software Foundation; either version 2 of the License, or
|
|
## (at your option) any later version.
|
|
##
|
|
## This program is distributed in the hope that it will be useful,
|
|
## but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
## GNU General Public License for more details.
|
|
##
|
|
## You should have received a copy of the GNU General Public License along
|
|
## with this program; if not, write to the Free Software Foundation, Inc.,
|
|
## 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
|
|
"""HID++ data and functions common to several logitech_receiver test files"""
|
|
|
|
|
|
import errno
|
|
import threading
|
|
|
|
from dataclasses import dataclass
|
|
from dataclasses import field
|
|
from struct import pack
|
|
from typing import Any
|
|
from typing import Optional
|
|
|
|
from logitech_receiver import device
|
|
from logitech_receiver import hidpp20
|
|
from solaar import configuration
|
|
|
|
|
|
def open_path(path: Optional[str]) -> int:
|
|
if path is None:
|
|
raise OSError(errno.EACCES, "Fake access error")
|
|
return int(path, 16) # can raise exception
|
|
|
|
|
|
@dataclass
|
|
class Response:
|
|
response: Optional[str]
|
|
id: int
|
|
params: str = ""
|
|
handle: int = 0x11
|
|
devnumber: int = 0xFF
|
|
no_reply: bool = False
|
|
|
|
|
|
def replace_number(responses, number): # change the devnumber for a list of responses
|
|
return [Response(r.response, r.id, r.params, r.handle, number, r.no_reply) for r in responses]
|
|
|
|
|
|
def ping(responses, handle, devnumber, long_message=False):
|
|
print("PING ", hex(handle), hex(devnumber) if devnumber else devnumber)
|
|
for r in responses:
|
|
if handle == r.handle and devnumber == r.devnumber and r.id == 0x0010:
|
|
print("RESPONSE", hex(r.handle), hex(r.devnumber), r.response)
|
|
return r.response
|
|
|
|
|
|
def request(responses, handle, devnumber, id, *params, no_reply=False, return_error=False, long_message=False, protocol=1.0):
|
|
params = b"".join(pack("B", p) if isinstance(p, int) else p for p in params)
|
|
print("REQUEST ", hex(handle), hex(devnumber), hex(id), params.hex())
|
|
for r in responses:
|
|
if handle == r.handle and devnumber == r.devnumber and r.id == id and bytes.fromhex(r.params) == params:
|
|
print("RESPONSE", hex(r.handle), hex(r.devnumber), hex(r.id), r.params, r.response)
|
|
return bytes.fromhex(r.response) if r.response is not None else None
|
|
|
|
|
|
r_empty = [ # a HID++ device with no responses except for ping
|
|
Response(1.0, 0x0010), # ping
|
|
]
|
|
|
|
r_keyboard_1 = [ # a HID++ 1.0 keyboard
|
|
Response(1.0, 0x0010), # ping
|
|
Response("001234", 0x81F1, "01"), # firmware
|
|
Response("003412", 0x81F1, "02"), # firmware
|
|
Response("002345", 0x81F1, "03"), # firmware
|
|
Response("003456", 0x81F1, "04"), # firmware
|
|
]
|
|
|
|
r_keyboard_2 = [ # a HID++ 2.0 keyboard
|
|
Response(4.2, 0x0010), # ping
|
|
Response("010001", 0x0000, "0001"), # feature set at 0x01
|
|
Response("020003", 0x0000, "1000"), # battery status at 0x02
|
|
Response("030001", 0x0000, "0003"), # device information at 0x03
|
|
Response("040003", 0x0000, "0100"), # unknown 0100 at 0x04
|
|
Response("050003", 0x0000, "1B04"), # reprogrammable keys V4 at 0x05
|
|
Response("08", 0x0100), # 8 features
|
|
Response("00010001", 0x0110, "01"), # feature set at 0x01
|
|
Response("10000001", 0x0110, "02"), # battery status at 0x02
|
|
Response("00030001", 0x0110, "03"), # device information at 0x03
|
|
Response("01000003", 0x0110, "04"), # unknown 0100 at 0x04
|
|
Response("1B040003", 0x0110, "05"), # reprogrammable keys V4 at 0x05
|
|
Response("0212345678000D1234567890ABAA01", 0x0300), # device information
|
|
Response("00110012AB010203CD00", 0x0510, "00"), # reprogrammable keys V4
|
|
Response("01110022AB010203CD00", 0x0510, "01"), # reprogrammable keys V4
|
|
Response("00010111AB010203CD00", 0x0510, "02"), # reprogrammable keys V4
|
|
Response("03110032AB010204CD00", 0x0510, "03"), # reprogrammable keys V4
|
|
Response("00030333AB010203CD00", 0x0510, "04"), # reprogrammable keys V4
|
|
]
|
|
|
|
r_mouse_1 = [ # a HID++ 1.0 mouse
|
|
Response(1.0, 0x0010), # ping
|
|
]
|
|
|
|
r_mouse_2 = [ # a HID++ 2.0 mouse with few responses except for ping
|
|
Response(4.2, 0x0010), # ping
|
|
]
|
|
|
|
r_mouse_3 = [ # a HID++ 2.0 mouse
|
|
Response(4.5, 0x0010), # ping
|
|
Response("010001", 0x0000, "0001"), # feature set at 0x01
|
|
Response("020002", 0x0000, "8060"), # report rate at 0x02
|
|
Response("040001", 0x0000, "0003"), # device information at 0x04
|
|
Response("050002", 0x0000, "0005"), # device type and name at 0x05
|
|
Response("08", 0x0100), # 8 features
|
|
Response("00010001", 0x0110, "01"), # feature set at 0x01
|
|
Response("80600002", 0x0110, "02"), # report rate at 0x02
|
|
Response("00030001", 0x0110, "04"), # device information at 0x04
|
|
Response("00050002", 0x0110, "05"), # device type and name at 0x05
|
|
Response("09", 0x0210), # report rate - current rate
|
|
Response("03123456790008123456780000AA01", 0x0400), # device information
|
|
Response("0141424302030100", 0x0410, "00"), # firmware 0
|
|
Response("0241", 0x0410, "01"), # firmware 1
|
|
Response("05", 0x0410, "02"), # firmware 2
|
|
Response("12", 0x0500), # name count - 18 characters
|
|
Response("414241424142414241424142414241", 0x0510, "00"), # name - first 15 characters
|
|
Response("444544000000000000000000000000", 0x0510, "0F"), # name - last 3 characters
|
|
]
|
|
|
|
responses_key = [
|
|
Response("08", 0x0500), # Reprogrammable Keys V4 count
|
|
Response("00500038010001010400000000000000", 0x0510, "00"), # left button
|
|
Response("00510039010001010400000000000000", 0x0510, "01"), # right button
|
|
Response("0052003A310003070500000000000000", 0x0510, "02"), # middle button
|
|
Response("0053003C710002030100000000000000", 0x0510, "03"), # back button
|
|
Response("0056003E710002030100000000000000", 0x0510, "04"), # forward button
|
|
Response("00C300A9310003070300000000000000", 0x0510, "05"), # smart shift?
|
|
Response("00C4009D310003070500000000000000", 0x0510, "06"), # ?
|
|
Response("00D700B4A00004000300000000000000", 0x0510, "07"), # ?
|
|
Response("00500000000000000000000000000000", 0x0520, "0050"), # left button
|
|
Response("00510000000000000000000000000000", 0x0520, "0051"), # ...
|
|
Response("00520100500000000000000000000000", 0x0520, "0052"),
|
|
Response("00530500000000000000000000000000", 0x0520, "0053"),
|
|
Response("00561100000000000000000000000000", 0x0520, "0056"),
|
|
Response("00C30000000000000000000000000000", 0x0520, "00C3"),
|
|
Response("00C40000500000000000000000000000", 0x0520, "00C4"),
|
|
Response("00D70000510000000000000000000000", 0x0520, "00D7"),
|
|
Response("0041", 0x0400), # flags
|
|
Response("0401", 0x0410), # count
|
|
Response("0050", 0x0420, "00FF"), # left button
|
|
Response("0051", 0x0420, "01FF"), # right button
|
|
Response("0052", 0x0420, "02FF"), # middle button
|
|
Response("0053", 0x0420, "03FF"), # back button
|
|
Response("0050000100500000", 0x0430, "0050FF"), # left button current
|
|
Response("0051000100500001", 0x0430, "0051FF"), # right button current
|
|
Response("0052000100500001", 0x0430, "0052FF"), # middle button current
|
|
Response("0053000100500001", 0x0430, "0053FF"), # back button current
|
|
Response("0050FF01005000", 0x0440, "0050FF01005000"), # left button write
|
|
Response("0051FF01005000", 0x0440, "0051FF01005000"), # right button write
|
|
Response("0051FF01005100", 0x0440, "0051FF01005100"), # right button set write
|
|
]
|
|
|
|
responses_XX = [ # a viable set of responses for Reprogrammable Keys V4
|
|
Response(4.2, 0x0010), # ping
|
|
Response("010001", 0x0000, "0001"), # feature set at 0x01
|
|
Response("020003", 0x0000, "1000"), # battery status at 0x02
|
|
Response("030001", 0x0000, "0003"), # device information at 0x03
|
|
Response("040003", 0x0000, "0100"), # unknown 0100 at 0x04
|
|
Response("050003", 0x0000, "1B04"), # reprogrammable keys V4 at 0x05
|
|
Response("08", 0x0100), # 8 features
|
|
Response("00010001", 0x0110, "01"), # feature set at 0x01
|
|
Response("10000001", 0x0110, "02"), # battery status at 0x02
|
|
Response("00030001", 0x0110, "03"), # device information at 0x03
|
|
Response("01000003", 0x0110, "04"), # unknown 0100 at 0x04
|
|
Response("1B040003", 0x0110, "05"), # reprogrammable keys V4 at 0x05
|
|
Response("0212345678000D1234567890ABAA01", 0x0300), # device information
|
|
Response("05", 0x0500), # reprogrammable keys V4
|
|
Response("00500038610000010100", 0x0510, "00"), # left button
|
|
Response("00510039600000010100", 0x0510, "01"), # right button
|
|
Response("0052003A110000020300", 0x0510, "02"), # middle button
|
|
Response("0053003C710101030700", 0x0510, "03"), # back button
|
|
Response("0056003E710102030700", 0x0510, "04"), # forward button
|
|
]
|
|
|
|
responses_gestures = [ # the commented-out messages are not used by either the setting or other testing
|
|
Response("4203410141020400320480148C21A301", 0x0400, "0000"), # items
|
|
Response("A302A11EA30A4105822C852DAD2AAD2B", 0x0400, "0008"),
|
|
Response("8F408F418F434204AF54912282558264", 0x0400, "0010"),
|
|
Response("01000000000000000000000000000000", 0x0400, "0018"),
|
|
Response("01000000000000000000000000000000", 0x0410, "000101"), # enable
|
|
# Response("02000000000000000000000000000000", 0x0410, "000102"),
|
|
# Response("04000000000000000000000000000000", 0x0410, "000104"),
|
|
# Response("08000000000000000000000000000000", 0x0410, "000108"),
|
|
Response("00000000000000000000000000000000", 0x0410, "000110"),
|
|
# Response("20000000000000000000000000000000", 0x0410, "000120"),
|
|
# Response("40000000000000000000000000000000", 0x0410, "000140"),
|
|
# Response("00000000000000000000000000000000", 0x0410, "000180"),
|
|
# Response("00000000000000000000000000000000", 0x0410, "010101"),
|
|
# Response("00000000000000000000000000000000", 0x0410, "010102"),
|
|
# Response("04000000000000000000000000000000", 0x0410, "010104"),
|
|
# Response("00000000000000000000000000000000", 0x0410, "010108"),
|
|
Response("6F000000000000000000000000000000", 0x0410, "0001FF"),
|
|
Response("04000000000000000000000000000000", 0x0410, "01010F"),
|
|
Response("00000000000000000000000000000000", 0x0430, "000101"), # divert
|
|
# Response("00000000000000000000000000000000", 0x0430, "000102"),
|
|
# Response("00000000000000000000000000000000", 0x0430, "000104"),
|
|
# Response("00000000000000000000000000000000", 0x0430, "000108"),
|
|
Response("00000000000000000000000000000000", 0x0430, "000110"),
|
|
# Response("00000000000000000000000000000000", 0x0430, "000120"),
|
|
# Response("00000000000000000000000000000000", 0x0430, "000140"),
|
|
# Response("00000000000000000000000000000000", 0x0430, "000180"),
|
|
# Response("00000000000000000000000000000000", 0x0430, "010101"),
|
|
# Response("00000000000000000000000000000000", 0x0430, "010102"),
|
|
Response("00000000000000000000000000000000", 0x0430, "0001FF"),
|
|
Response("00000000000000000000000000000000", 0x0430, "010103"),
|
|
Response("08000000000000000000000000000000", 0x0450, "01FF"),
|
|
Response("08000000000000000000000000000000", 0x0450, "02FF"),
|
|
Response("08000000000000000000000000000000", 0x0450, "03FF"),
|
|
Response("00040000000000000000000000000000", 0x0450, "04FF"),
|
|
Response("5C020000000000000000000000000000", 0x0450, "05FF"),
|
|
Response("01000000000000000000000000000000", 0x0460, "00FF"),
|
|
Response("01000000000000000000000000000000", 0x0470, "00FF"),
|
|
Response("01", 0x0420, "00010101"), # set index 1
|
|
Response("00", 0x0420, "00010100"), # unset index 1
|
|
Response("01", 0x0420, "00011010"), # set index 4
|
|
Response("00", 0x0420, "00011000"), # unset index 4
|
|
Response("01", 0x0440, "00010101"), # divert index 1
|
|
Response("00", 0x0440, "00010100"), # undivert index 1
|
|
Response("000080FF", 0x0480, "000080FF"), # write param 0
|
|
Response("000180FF", 0x0480, "000180FF"), # write param 0
|
|
]
|
|
|
|
|
|
# A fake device that uses provided data (responses) to respond to HID++ commands.
|
|
# Some methods from the real device are used to set up data structures needed for settings
|
|
@dataclass
|
|
class Device:
|
|
name: str = "TESTD"
|
|
online: bool = True
|
|
protocol: float = 2.0
|
|
responses: Any = field(default_factory=list)
|
|
codename: str = "TESTC"
|
|
feature: Optional[int] = None
|
|
offset: Optional[int] = 4
|
|
version: Optional[int] = 0
|
|
wpid: Optional[str] = "0000"
|
|
setting_callback: Any = None
|
|
settings = []
|
|
sliding = profiles = _backlight = _keys = _remap_keys = _led_effects = _gestures = None
|
|
_gestures_lock = threading.Lock()
|
|
|
|
read_register = device.Device.read_register
|
|
write_register = device.Device.write_register
|
|
backlight = device.Device.backlight
|
|
keys = device.Device.keys
|
|
remap_keys = device.Device.remap_keys
|
|
led_effects = device.Device.led_effects
|
|
gestures = device.Device.gestures
|
|
__hash__ = device.Device.__hash__
|
|
|
|
def __post_init__(self):
|
|
self.persister = configuration._DeviceEntry()
|
|
if self.feature is not None:
|
|
self.features = hidpp20.FeaturesArray(self)
|
|
self.responses = [Response("010001", 0x0000, "0001"), Response("20", 0x0100)] + self.responses
|
|
self.responses.append(Response(f"{self.offset:0>2X}00{self.version:0>2X}", 0x0000, f"{self.feature:0>4X}"))
|
|
if self.setting_callback is None:
|
|
self.setting_callback = lambda x, y, z: None
|
|
self.add_notification_handler = lambda x, y: None
|
|
|
|
def request(self, id, *params, no_reply=False):
|
|
if params is None:
|
|
params = []
|
|
params = b"".join(pack("B", p) if isinstance(p, int) else p for p in params)
|
|
print("REQUEST ", self.name, hex(id), params.hex().upper())
|
|
for r in self.responses:
|
|
if id == r.id and params == bytes.fromhex(r.params):
|
|
print("RESPONSE", self.name, hex(r.id), r.params, r.response)
|
|
return bytes.fromhex(r.response) if isinstance(r.response, str) else r.response
|
|
print("RESPONSE", self.name, None)
|
|
|
|
def feature_request(self, feature, function=0x00, *params, no_reply=False):
|
|
if self.protocol >= 2.0:
|
|
return hidpp20.feature_request(self, feature, function, *params, no_reply=no_reply)
|
|
|
|
|
|
def match_requests(number, responses, call_args_list):
|
|
for i in range(0 - number, 0):
|
|
param = b"".join(pack("B", p) if isinstance(p, int) else p for p in call_args_list[i][0][1:]).hex().upper()
|
|
print("MATCH", i, hex(call_args_list[i][0][0]), param, hex(responses[i].id), responses[i].params)
|
|
assert call_args_list[i][0][0] == responses[i].id
|
|
assert param == responses[i].params
|