Revert "Config flow"

Author: Ernst79

.gitignore

@@ -1,31 +1,23 @@
 """Passive BLE monitor integration."""
 import asyncio
-import copy
-from Cryptodome.Cipher import AES
-import json
 import logging
 import queue
 import struct
 from threading import Thread
 import voluptuous as vol
-
-from homeassistant.config_entries import SOURCE_IMPORT, ConfigEntry
+from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers import discovery
 from homeassistant.const import (
     CONF_DEVICES,
     CONF_DISCOVERY,
     CONF_MAC,
     CONF_NAME,
     CONF_TEMPERATURE_UNIT,
     EVENT_HOMEASSISTANT_STOP,
-    TEMP_CELSIUS,
-    TEMP_FAHRENHEIT,
-)
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers import config_validation as cv
-from homeassistant.helpers.entity_registry import (
-    async_entries_for_device,
 )
 
+from Cryptodome.Cipher import AES
+
 # It was decided to temporarily include this file in the integration bundle
 # until the issue with checking the adapter's capabilities is resolved in the official aioblescan repo
 # see https://github.com/frawau/aioblescan/pull/30, thanks to @vicamo
@@ -38,11 +30,11 @@
     DEFAULT_LOG_SPIKES,
     DEFAULT_USE_MEDIAN,
     DEFAULT_ACTIVE_SCAN,
+    DEFAULT_HCI_INTERFACE,
     DEFAULT_BATT_ENTITIES,
     DEFAULT_REPORT_UNKNOWN,
     DEFAULT_DISCOVERY,
     DEFAULT_RESTORE_STATE,
-    DEFAULT_HCI_INTERFACE,
     CONF_ROUNDING,
     CONF_DECIMALS,
     CONF_PERIOD,
@@ -54,12 +46,8 @@
     CONF_REPORT_UNKNOWN,
     CONF_RESTORE_STATE,
     CONF_ENCRYPTION_KEY,
-    CONFIG_IS_FLOW,
     DOMAIN,
-    MAC_REGEX,
-    AES128KEY_REGEX,
     XIAOMI_TYPE_DICT,
-    SERVICE_CLEANUP_ENTRIES,
 )
 
 _LOGGER = logging.getLogger(__name__)
@@ -72,10 +60,9 @@
 ILL_STRUCT = struct.Struct("<I")
 FMDH_STRUCT = struct.Struct("<H")
 
-PLATFORMS = ["binary_sensor", "sensor"]
-
-CONFIG_YAML = {}
-UPDATE_UNLISTENER = None
+# regex constants for configuration schema
+MAC_REGEX = "(?i)^(?:[0-9A-F]{2}[:]){5}(?:[0-9A-F]{2})$"
+AES128KEY_REGEX = "(?i)^[A-F0-9]{32}$"
 
 DEVICE_SCHEMA = vol.Schema(
     {
@@ -116,183 +103,18 @@
     extra=vol.ALLOW_EXTRA,
 )
 
-SERVICE_CLEANUP_ENTRIES_SCHEMA = vol.Schema({})
 
-
-async def async_setup(hass: HomeAssistant, config):
+def setup(hass, config):
     """Set up integration."""
-
-    async def service_cleanup_entries(service_call):
-        # service = service_call.service
-        service_data = service_call.data
-
-        await async_cleanup_entries_service(hass, service_data)
-
-    hass.services.async_register(
-        DOMAIN,
-        SERVICE_CLEANUP_ENTRIES,
-        service_cleanup_entries,
-        schema=SERVICE_CLEANUP_ENTRIES_SCHEMA,
-    )
-
-    if DOMAIN not in config:
-        return True
-
-    if DOMAIN in hass.data:
-        # One instance only
-        return False
-
-    # Save and set default for the YAML config
-    global CONFIG_YAML
-    CONFIG_YAML = json.loads(json.dumps(config[DOMAIN]))
-    CONFIG_YAML[CONFIG_IS_FLOW] = False
-
-    _LOGGER.debug("Initializing BLE Monitor integration (YAML): %s", CONFIG_YAML)
-
-    hass.async_add_job(
-        hass.config_entries.flow.async_init(
-            DOMAIN, context={"source": SOURCE_IMPORT}, data=copy.deepcopy(CONFIG_YAML)
-        )
-    )
-
-    return True
-
-
-async def async_setup_entry(hass: HomeAssistant, config_entry: ConfigEntry):
-    """Set up BLE Monitor from a config entry."""
-    _LOGGER.debug("Initializing BLE Monitor entry (config entry): %s", config_entry)
-
-    # Prevent unload to be triggered each time we update the config entry
-    global UPDATE_UNLISTENER
-    if UPDATE_UNLISTENER:
-        UPDATE_UNLISTENER()
-
-    if not config_entry.unique_id:
-        hass.config_entries.async_update_entry(config_entry, unique_id=config_entry.title)
-
-    _LOGGER.debug("async_setup_entry: domain %s", CONFIG_YAML)
-
-    config = {}
-
-    if not CONFIG_YAML:
-        for key, value in config_entry.data.items():
-            config[key] = value
-
-        for key, value in config_entry.options.items():
-            config[key] = value
-
-        config[CONFIG_IS_FLOW] = True
-        if CONF_DEVICES not in config:
-            config[CONF_DEVICES] = []
-    else:
-        for key, value in CONFIG_YAML.items():
-            config[key] = value
-        if CONF_HCI_INTERFACE in CONFIG_YAML:
-            hci_list = []
-            if isinstance(CONFIG_YAML[CONF_HCI_INTERFACE], list):
-                for hci in CONFIG_YAML[CONF_HCI_INTERFACE]:
-                    hci_list.append(str(hci))
-            else:
-                hci_list.append(str(CONFIG_YAML[CONF_HCI_INTERFACE]))
-            config[CONF_HCI_INTERFACE] = hci_list
-
-    hass.config_entries.async_update_entry(config_entry, data={}, options=config)
-
-    _LOGGER.debug("async_setup_entry: %s", config)
-
-    UPDATE_UNLISTENER = config_entry.add_update_listener(_async_update_listener)
-
-    if CONF_HCI_INTERFACE not in config:
-        config[CONF_HCI_INTERFACE] = [DEFAULT_HCI_INTERFACE]
-    else:
-        hci_list = config_entry.options.get(CONF_HCI_INTERFACE)
-        for i, hci in enumerate(hci_list):
-            hci_list[i] = int(hci)
-        config[CONF_HCI_INTERFACE] = hci_list
-    _LOGGER.debug("HCI interface is %s", config[CONF_HCI_INTERFACE])
-
-    blemonitor = BLEmonitor(config)
-    hass.bus.async_listen(EVENT_HOMEASSISTANT_STOP, blemonitor.shutdown_handler)
+    blemonitor = BLEmonitor(config[DOMAIN])
+    hass.bus.listen(EVENT_HOMEASSISTANT_STOP, blemonitor.shutdown_handler)
     blemonitor.start()
-
-    hass.data[DOMAIN] = {}
-    hass.data[DOMAIN]["blemonitor"] = blemonitor
-    hass.data[DOMAIN]["config_entry_id"] = config_entry.entry_id
-
-    for component in PLATFORMS:
-        hass.async_create_task(
-            hass.config_entries.async_forward_entry_setup(config_entry, component)
-        )
-
+    hass.data[DOMAIN] = blemonitor
+    discovery.load_platform(hass, "sensor", DOMAIN, {}, config)
+    discovery.load_platform(hass, "binary_sensor", DOMAIN, {}, config)
     return True
 
 
-async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry):
-    """Unload a config entry."""
-    _LOGGER.debug("async_unload_entry: %s", entry)
-
-    unload_ok = all(
-        await asyncio.gather(
-            *[
-                hass.config_entries.async_forward_entry_unload(entry, component)
-                for component in PLATFORMS
-            ]
-        )
-    )
-    blemonitor: BLEmonitor = hass.data[DOMAIN]["blemonitor"]
-    if blemonitor:
-        blemonitor.stop()
-
-    return unload_ok
-
-
-async def _async_update_listener(hass: HomeAssistant, entry: ConfigEntry) -> None:
-    """Handle options update."""
-    await hass.config_entries.async_reload(entry.entry_id)
-
-
-async def async_cleanup_entries_service(hass: HomeAssistant, data):
-    """Remove orphaned entries from device and entity registries."""
-    _LOGGER.debug("async_cleanup_entries_service")
-
-    entity_registry = await hass.helpers.entity_registry.async_get_registry()
-    device_registry = await hass.helpers.device_registry.async_get_registry()
-    config_entry_id = hass.data[DOMAIN]["config_entry_id"]
-
-    # entity_entries = async_entries_for_config_entry(
-    #     entity_registry, config_entry_id
-    # )
-
-    # entities_to_be_removed = []
-    devices_to_be_removed = [
-        entry.id
-        for entry in device_registry.devices.values()
-        if config_entry_id in entry.config_entries
-    ]
-
-    # for entry in entity_entries:
-
-    #     # Don't remove available entities
-    #     if entry.unique_id in gateway.entities[entry.domain]:
-
-    #         # Don't remove devices with available entities
-    #         if entry.device_id in devices_to_be_removed:
-    #             devices_to_be_removed.remove(entry.device_id)
-    #         continue
-    #     # Remove entities that are not available
-    #     entities_to_be_removed.append(entry.entity_id)
-
-    # # Remove unavailable entities
-    # for entity_id in entities_to_be_removed:
-    #     entity_registry.async_remove(entity_id)
-
-    # Remove devices that don't belong to any entity
-    for device_id in devices_to_be_removed:
-        if len(async_entries_for_device(entity_registry, device_id)) == 0:
-            device_registry.async_remove_device(device_id)
-            _LOGGER.debug("device %s will be deleted", device_id)
-
-
 class BLEmonitor:
     """BLE scanner."""
 
@@ -303,8 +125,6 @@ def __init__(self, config):
             "measuring": queue.SimpleQueue(),
         }
         self.config = config
-        if config[CONF_REPORT_UNKNOWN] is True:
-            _LOGGER.info("Attention! Option report_unknown is enabled, be ready for a huge output...")
         self.dumpthread = None
 
     def shutdown_handler(self, event):
@@ -421,17 +241,17 @@ def reverse_mac(rmac):
         self.report_unknown = False
         if self.config[CONF_REPORT_UNKNOWN]:
             self.report_unknown = True
-            _LOGGER.debug(
+            _LOGGER.info(
                 "Attention! Option report_unknown is enabled, be ready for a huge output..."
             )
         # prepare device:key lists to speedup parser
         if self.config[CONF_DEVICES]:
             for device in self.config[CONF_DEVICES]:
-                if CONF_ENCRYPTION_KEY in device and device[CONF_ENCRYPTION_KEY]:
+                if "encryption_key" in device:
                     p_mac = bytes.fromhex(
                         reverse_mac(device["mac"].replace(":", "")).lower()
                     )
-                    p_key = bytes.fromhex(device[CONF_ENCRYPTION_KEY].lower())
+                    p_key = bytes.fromhex(device["encryption_key"].lower())
                     self.aeskeys[p_mac] = p_key
                 else:
                     continue

README.md

@@ -1,4 +1,4 @@
-"""Passive BLE monitor binary sensor platform."""
+"""Passive BLE monitor sensor platform."""
 from datetime import timedelta
 import logging
 import queue
@@ -11,39 +11,34 @@
     BinarySensorEntity,
 )
 from homeassistant.const import (
-    CONF_DEVICES,
     ATTR_BATTERY_LEVEL,
     STATE_OFF,
     STATE_ON,
 )
 from homeassistant.helpers.restore_state import RestoreEntity
 import homeassistant.util.dt as dt_util
 
-from .const import (
+from . import (
+    CONF_DEVICES,
     CONF_PERIOD,
     CONF_BATT_ENTITIES,
     CONF_RESTORE_STATE,
-    MANUFACTURER_DICT,
-    MMTS_DICT,
+)
+from .const import (
     DOMAIN,
+    MMTS_DICT,
 )
 
 _LOGGER = logging.getLogger(__name__)
 
 
-async def async_setup_platform(hass, conf, add_entities, discovery_info=None):
-    """setup from setup_entry"""
-    return True
-
-
-async def async_setup_entry(hass, config_entry, add_entities):
-    """Set up the binary sensor platform."""
-    _LOGGER.debug("Starting binary sensor entry startup")
-
-    blemonitor = hass.data[DOMAIN]["blemonitor"]
+def setup_platform(hass, conf, add_entities, discovery_info=None):
+    """Set up the binary_sensor platform."""
+    _LOGGER.debug("Binary sensor platform setup")
+    blemonitor = hass.data[DOMAIN]
     bleupdater = BLEupdaterBinary(blemonitor, add_entities)
     bleupdater.start()
-    _LOGGER.debug("Binary sensor entry setup finished")
+    _LOGGER.debug("Binary sensor platform setup finished")
     # Return successful setup
     return True
 
@@ -177,7 +172,6 @@ def __init__(self, config, mac, devtype):
         self._state = None
         self._unique_id = ""
         self._device_type = devtype
-        self._device_manufacturer = MANUFACTURER_DICT[devtype]
         self._device_state_attributes = {}
         self._device_state_attributes["sensor type"] = devtype
         self._device_state_attributes["mac address"] = (
@@ -248,18 +242,6 @@ def device_class(self):
         """Return the device class."""
         return self._device_class
 
-    @property
-    def device_info(self):
-        return {
-            "identifiers": {
-                # Unique identifiers within a specific domain
-                (DOMAIN, self._device_state_attributes["mac address"])
-            },
-            "name": self.get_sensorname(),
-            "model": self._device_type,
-            "manufacturer": self._device_manufacturer,
-        }
-
     @property
     def force_update(self):
         """Force update."""