Merge b798c88 into f62986e

Author: LeonarddeR

source/bdDetect.py

@@ -13,7 +13,7 @@
 """
 
 import itertools
-from collections import namedtuple, defaultdict, OrderedDict
+from collections import defaultdict, OrderedDict
 import threading
 from concurrent.futures import ThreadPoolExecutor, Future
 import typing
@@ -26,28 +26,43 @@
 from baseObject import AutoPropertyObject
 import re
 from winAPI import messageWindow
+import extensionPoints
 
 
 HID_USAGE_PAGE_BRAILLE = 0x41
 
-
 DBT_DEVNODES_CHANGED=7
 
 _driverDevices = OrderedDict()
 USB_ID_REGEX = re.compile(r"^VID_[0-9A-F]{4}&PID_[0-9A-F]{4}$", re.U)
 
-class DeviceMatch(
-	namedtuple("DeviceMatch", ("type","id", "port", "deviceInfo"))
-):
+
+class DeviceMatch(typing.NamedTuple):
 	"""Represents a detected device.
-	@ivar id: The identifier of the device.
-	@type id: str
-	@ivar port: The port that can be used by a driver to communicate with a device.
-	@type port: str
-	@ivar deviceInfo: all known information about a device.
-	@type deviceInfo: dict
 	"""
-	__slots__ = ()
+	type: str
+	"""The type of the device."""
+	id: str
+	"""The identifier of the device."""
+	port: str
+	"""The port that can be used by a driver to communicate with a device."""
+	deviceInfo: typing.Dict[str, str]
+	"""all known information about a device."""
+
+
+scanForDevices = extensionPoints.Chain[typing.Tuple[str, DeviceMatch]]()
+"""
+A Chain that can be iterated to scan for devices.
+Registered handlers should yield a tuple containing a driver name as str and DeviceMatch
+Handlers are called with these keyword arguments:
+@param detectUsb: Whether the handler is expected to yield USB devices.
+@type detectUsb: bool
+@param detectBluetooth: Whether the handler is expected to yield USB devices.
+@type detectBluetooth: bool
+@param limitToDevices: Drivers to which detection should be limited.
+	C{None} if no driver filtering should occur.
+"""
+
 
 # Device type constants
 #: Key constant for HID devices
@@ -210,6 +225,24 @@ class _DeviceInfoFetcher(AutoPropertyObject):
 	"""Utility class that caches fetched info for available devices for the duration of one core pump cycle."""
 	cachePropertiesByDefault = True
 
+	def __init__(self):
+		self._btDevsLock = threading.Lock
+		self._btDevsCache: typing.Optional[typing.Tuple[str, DeviceMatch]] = None
+
+	#: Type info for auto property: _get_btDevsCache
+	btDevsCache: typing.Optional[typing.List[typing.Tuple[str, DeviceMatch]]]
+
+	def _get_btDevsCache(self):
+		with self._btDevsLock():
+			return self._btDevsCache
+
+	def _set_btDevsCache(
+			self,
+			cache: typing.Optional[typing.List[typing.Tuple[str, DeviceMatch]]]
+	):
+		with self._btDevsLock():
+			self._btDevsCache = cache
+
 	#: Type info for auto property: _get_comPorts
 	comPorts: typing.List[typing.Dict]
 
@@ -228,42 +261,27 @@ def _get_usbDevices(self) -> typing.List[typing.Dict]:
 	def _get_hidDevices(self) -> typing.List[typing.Dict]:
 		return list(hwPortUtils.listHidDevices(onlyAvailable=True))
 
-#: The single instance of the device info fetcher.
-#: @type: L{_DeviceInfoFetcher}
-deviceInfoFetcher = _DeviceInfoFetcher()
+
+deviceInfoFetcher: _DeviceInfoFetcher
+
 
 class Detector(object):
 	"""Detector class used to automatically detect braille displays.
 	This should only be used by the L{braille} module.
 	"""
 
-	def __init__(
-			self,
-			usb: bool = True,
-			bluetooth: bool = True,
-			limitToDevices: typing.Optional[typing.List[str]] = None
-	):
+	def __init__(self):
 		"""Constructor.
-		The keyword arguments initialize the detector in a particular state.
-		On an initialized instance, these initial arguments can be overridden by calling
-		L{_queueBgScan} or L{rescan}.
-		@param usb: Whether this instance should detect USB devices initially.
-		@param bluetooth: Whether this instance should detect Bluetooth devices initially.
-		@param limitToDevices: Drivers to which detection should be limited initially.
-			C{None} if no driver filtering should occur.
+		After construction, a scan should be queued with L{queueBgScan}.
 		"""
 		self._executor = ThreadPoolExecutor(1)
-		self._btDevsLock = threading.Lock()
-		self._btDevs: typing.Optional[typing.Tuple[str, DeviceMatch]] = None
 		self._queuedFuture: typing.Optional[Future] = None
 		messageWindow.pre_handleWindowMessage.register(self.handleWindowMessage)
 		appModuleHandler.post_appSwitch.register(self.pollBluetoothDevices)
 		self._stopEvent = threading.Event()
-		self._detectUsb = usb
-		self._detectBluetooth = bluetooth
-		self._limitToDevices = limitToDevices
-		# Perform initial scan.
-		self._queueBgScan(usb=usb, bluetooth=bluetooth, limitToDevices=limitToDevices)
+		self._detectUsb = True
+		self._detectBluetooth = True
+		self._limitToDevices = None
 
 	def _queueBgScan(
 			self,
@@ -296,50 +314,46 @@ def _stopBgScan(self):
 			# If this future belongs to a scan that is currently running or finished, this does nothing.
 			self._queuedFuture.cancel()
 
-	def _bgScanUsb(self, limitToDevices: typing.Optional[typing.List[str]]):
-		"""Helper method to perform background scanning for USB devices.
-		@param limitToDevices: Drivers to which detection should be limited for this scan.
-			C{None} if no driver filtering should occur.
+	@staticmethod
+	def _bgScanUsb(
+			detectUsb: bool = True,
+			limitToDevices: typing.Optional[typing.List[str]] = None,
+	):
+		"""Handler for L{scanForDevices} that yields USB devices.
+		See the L{scanForDevices} documentation for information about the parameters.
 		"""
-		if self._stopEvent.isSet():
+		if not detectUsb:
 			return
 		for driver, match in getDriversForConnectedUsbDevices():
-			if self._stopEvent.isSet():
-				return
 			if limitToDevices and driver not in limitToDevices:
 				continue
-			if braille.handler.setDisplayByName(driver, detected=match):
-				return
+			yield (driver, match)
 
-	def _bgScanBluetooth(self, limitToDevices: typing.Optional[typing.List[str]]):
-		"""Helper method to perform background scanning for Bluetooth devices.
-		@param limitToDevices: Drivers to which detection should be limited for this scan.
-			C{None} if no driver filtering should occur.
+	@staticmethod
+	def _bgScanBluetooth(
+			detectBluetooth: bool = True,
+			limitToDevices: typing.Optional[typing.List[str]] = None,
+	):
+		"""Handler for L{scanForDevices} that yields Bluetooth devices and keeps an internal cache of devices.
+		See the L{scanForDevices} documentation for information about the parameters.
 		"""
-		if self._stopEvent.isSet():
+		if not detectBluetooth:
 			return
-		with self._btDevsLock:
-			if self._btDevs is None:
-				btDevs = list(getDriversForPossibleBluetoothDevices())
-				# Cache Bluetooth devices for next time.
-				btDevsCache = []
-			else:
-				btDevs = self._btDevs
-				btDevsCache = btDevs
+		btDevs: typing.Optional[typing.Iterable[typing.Tuple[str, DeviceMatch]]] = _DeviceInfoFetcher.btDevsCache
+		if btDevs is None:
+			btDevs = getDriversForPossibleBluetoothDevices()
+			# Cache Bluetooth devices for next time.
+			btDevsCache = []
+		else:
+			btDevsCache = btDevs
 		for driver, match in btDevs:
-			if self._stopEvent.isSet():
-				return
 			if limitToDevices and driver not in limitToDevices:
 				continue
 			if btDevsCache is not btDevs:
 				btDevsCache.append((driver, match))
-			if braille.handler.setDisplayByName(driver, detected=match):
-				return
-		if self._stopEvent.isSet():
-			return
+			yield (driver, match)
 		if btDevsCache is not btDevs:
-			with self._btDevsLock:
-				self._btDevs = btDevsCache
+			_DeviceInfoFetcher.btDevsCache = btDevsCache
 
 	def _bgScan(
 			self,
@@ -357,10 +371,18 @@ def _bgScan(
 		# Clear the stop event before a scan is started.
 		# Since a scan can take some time to complete, another thread can set the stop event to cancel it.
 		self._stopEvent.clear()
-		if detectUsb:
-			self._bgScanUsb(limitToDevices)
-		if detectBluetooth:
-			self._bgScanBluetooth(limitToDevices)
+		iterator = scanForDevices.iter(
+			detectUsb=detectUsb,
+			detectBluetooth=detectBluetooth,
+			limitToDevices=limitToDevices,
+		)
+		for driver, match in iterator:
+			if self._stopEvent.is_set():
+				return
+			if braille.handler.setDisplayByName(driver, detected=match):
+				return
+			if self._stopEvent.is_set():
+				return
 
 	def rescan(self, usb=True, bluetooth=True, limitToDevices=None):
 		"""Stop a current scan when in progress, and start scanning from scratch.
@@ -372,9 +394,8 @@ def rescan(self, usb=True, bluetooth=True, limitToDevices=None):
 			C{None} if no driver filtering should occur.
 		"""
 		self._stopBgScan()
-		with self._btDevsLock:
-			# A Bluetooth com port or HID device might have been added.
-			self._btDevs = None
+		# Clear the cache of bluetooth devices so new devices can be picked up.
+		_DeviceInfoFetcher.btDevsCache = None
 		self._queueBgScan(usb=usb, bluetooth=bluetooth, limitToDevices=limitToDevices)
 
 	def handleWindowMessage(self, msg=None, wParam=None):
@@ -387,15 +408,16 @@ def pollBluetoothDevices(self):
 		if not self._detectBluetooth:
 			# Do not poll bluetooth devices at all when bluetooth is disabled.
 			return
-		with self._btDevsLock:
-			if not self._btDevs:
-				return
+		if not _DeviceInfoFetcher.btDevsCache:
+			return
 		self._queueBgScan(bluetooth=self._detectBluetooth, limitToDevices=self._limitToDevices)
 
 	def terminate(self):
 		appModuleHandler.post_appSwitch.unregister(self.pollBluetoothDevices)
 		messageWindow.pre_handleWindowMessage.unregister(self.handleWindowMessage)
 		self._stopBgScan()
+		# Clear the cache of bluetooth devices so new devices can be picked up with a new instance.
+		_DeviceInfoFetcher.btDevsCache = None
 		self._executor.shutdown(wait=False)
 
 
@@ -479,12 +501,19 @@ def driverSupportsAutoDetection(driver):
 	return driver in _driverDevices
 
 
-def initializeDetectionData():
-	""" Initialize detection data.
+def initialize():
+	""" Initializes bdDetect, such as detection data.
 	Calls to addUsbDevices, and addBluetoothDevices.
 	Specify the requirements for a detected device to be considered a
 	match for a specific driver.
 	"""
+	global deviceInfoFetcher
+	deviceInfoFetcher = _DeviceInfoFetcher()
+
+	scanForDevices.register(Detector._bgScanUsb)
+	scanForDevices.register(Detector._bgScanBluetooth)
+
+	# Add devices
 	# alva
 	addUsbDevices("alva", KEY_HID, {
 		"VID_0798&PID_0640",  # BC640
@@ -733,3 +762,11 @@ def initializeDetectionData():
 		"seikantk",
 		isSeikaBluetoothDeviceMatch
 	)
+
+
+def terminate():
+	global deviceInfoFetcher
+	_driverDevices.clear()
+	scanForDevices.unregister(Detector._bgScanBluetooth)
+	scanForDevices.unregister(Detector._bgScanUsb)
+	del deviceInfoFetcher

source/braille.py

@@ -1892,15 +1892,14 @@ class BrailleHandler(baseObject.AutoPropertyObject):
 	@type currentCellCount: bool
 	"""
 
-	filter_displaySize: extensionPoints.Filter
+	filter_displaySize: extensionPoints.Filter[int]
 	"""
 	Filter that allows components or add-ons to change the display size used for braille output.
 	For example, when a system is controlled by a remote system while having a 80 cells display connected,
 	the display size should be lowered to 40 whenever the remote system has a 40 cells display connected.
 	@param value: the number of cells of the current display.
 	@type value: int
 	"""
-
 	displaySizeChanged: extensionPoints.Action
 	"""
 	Action that allows components or add-ons to be notified of display size changes.
@@ -2089,7 +2088,6 @@ def setDisplayByName(  # noqa: C901
 			# or situations where the user hasn't set any port.
 			if port:
 				kwargs["port"] = port
-
 		try:
 			newDisplay = _getDisplayDriver(name)
 			oldDisplay = self.display
@@ -2517,8 +2515,9 @@ def _enableDetection(self, usb=True, bluetooth=True, keepCurrentDisplay=False, l
 		config.conf["braille"]["display"] = AUTO_DISPLAY_NAME
 		if not keepCurrentDisplay:
 			self.setDisplayByName("noBraille", isFallback=True)
-		self._detector = bdDetect.Detector(usb=usb, bluetooth=bluetooth, limitToDevices=limitToDevices)
+		self._detector = bdDetect.Detector()
 		self._detectionEnabled = True
+		self._detector._queueBgScan(usb=usb, bluetooth=bluetooth, limitToDevices=limitToDevices)
 
 	def _disableDetection(self):
 		"""Disables automatic detection of braille displays."""
@@ -2596,7 +2595,6 @@ def initialize():
 	newTableName = brailleTables.RENAMED_TABLES.get(oldTableName)
 	if newTableName:
 		config.conf["braille"]["translationTable"] = newTableName
-	bdDetect.initializeDetectionData()
 	handler = BrailleHandler()
 	# #7459: the syncBraille has been dropped in favor of the native hims driver.
 	# Migrate to renamed drivers as smoothly as possible.

source/core.py

@@ -212,6 +212,7 @@ def resetConfiguration(factoryDefaults=False):
 	import speech
 	import vision
 	import inputCore
+	import bdDetect
 	import hwIo
 	import tones
 	log.debug("Terminating vision")
@@ -224,6 +225,8 @@ def resetConfiguration(factoryDefaults=False):
 	speech.terminate()
 	log.debug("terminating tones")
 	tones.terminate()
+	log.debug("Terminating background braille display detection")
+	bdDetect.terminate()
 	log.debug("Terminating background i/o")
 	hwIo.terminate()
 	log.debug("terminating addonHandler")
@@ -243,6 +246,8 @@ def resetConfiguration(factoryDefaults=False):
 	# Hardware background i/o
 	log.debug("initializing background i/o")
 	hwIo.initialize()
+	log.debug("Initializing background braille display detection")
+	bdDetect.initialize()
 	# Tones
 	tones.initialize()
 	#Speech
@@ -521,6 +526,9 @@ def main():
 	log.debug("initializing background i/o")
 	import hwIo
 	hwIo.initialize()
+	log.debug("Initializing background braille display detection")
+	import bdDetect
+	bdDetect.initialize()
 	log.debug("Initializing tones")
 	import tones
 	tones.initialize()
@@ -791,6 +799,7 @@ def _doPostNvdaStartupAction():
 	_terminate(brailleInput)
 	_terminate(braille)
 	_terminate(speech)
+	_terminate(bdDetect)
 	_terminate(hwIo)
 	_terminate(addonHandler)
 	_terminate(garbageHandler)