Disable unreliable battery entity by default and improve user resolution logic for measurements

Author: ronnnnnnnnnnnnn

README.md

@@ -59,6 +59,7 @@ Known-incompatible:
 | Marketed model | HVIN        | FCC ID              |
 |----------------|-------------|---------------------|
 | ES-CS20M       | `ESCS20MB2` | `2A26P-ESCS20MB2`   |
+| ES-CS20M       | -           | `2APXUES-CS20M`     |
 
 **How to find your HVIN:** look at the regulatory sticker on the back of the scale. Most stickers have a dedicated `HVIN:` field alongside the FCC ID. Some stickers don't — in that case, look at the trailing portion of the **FCC ID** (`2A26P-<code>`), which encodes the same identifier. The trailing revision suffix (`A2`, `B2`, `N`, or absent altogether) is what matters. If your HVIN or FCC ID matches a confirmed-working entry above, this integration is likely to work; if it matches a known-incompatible entry it's unlikely to work; if it doesn't match an entry in either table, try it out and report back on the issue tracker. (Note: neither HVIN nor model number is readable over BLE, so the device code can't be shown on the Home Assistant device card — you have to read it off the sticker.)
 

custom_components/renpho_fitness_scale_ble/__init__.py

@@ -12,6 +12,7 @@
 from homeassistant.core import HomeAssistant, ServiceCall, callback
 from homeassistant.exceptions import ConfigEntryNotReady, HomeAssistantError
 from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers import entity_registry as er
 from homeassistant.helpers.start import async_at_started
 
 from .const import (
@@ -157,6 +158,42 @@ async def _handle_mobile_app_action(hass: HomeAssistant, event) -> None:
 # ---------------------------------------------------------------------------
 
 
+@callback
+def _disable_battery_entities(hass: HomeAssistant, entry: ConfigEntry) -> None:
+    """Disable any still-enabled ``*_battery`` sensor for this entry.
+
+    Tested devices seem to report a static 100% on the Battery Level
+    characteristic (see :class:`ScaleBatterySensor`), so the entity is
+    disabled by default. New installs get that via
+    ``entity_registry_enabled_default``; this brings existing installs in
+    line. Only entities the user hasn't already disabled are touched, and the
+    one-time ``minor_version`` guard in :func:`async_migrate_entry` means a
+    later deliberate re-enable is never overridden.
+    """
+    registry = er.async_get(hass)
+    for reg_entry in er.async_entries_for_config_entry(registry, entry.entry_id):
+        if (
+            reg_entry.domain == "sensor"
+            and reg_entry.unique_id.endswith("_battery")
+            and reg_entry.disabled_by is None
+        ):
+            registry.async_update_entity(
+                reg_entry.entity_id,
+                disabled_by=er.RegistryEntryDisabler.INTEGRATION,
+            )
+
+
+async def async_migrate_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+    """Migrate older config entries. Called automatically by HA when a stored
+    entry's version is behind the config flow's ``VERSION``/``MINOR_VERSION``."""
+    if entry.version == 1 and entry.minor_version < 2:
+        # 1.1 → 1.2: disable the (unreliable on observed hardware) battery
+        # entity for installs that registered it while it was enabled.
+        _disable_battery_entities(hass, entry)
+        hass.config_entries.async_update_entry(entry, minor_version=2)
+    return True
+
+
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Set up a Renpho scale from a config entry."""
     hass.data.setdefault(DOMAIN, {})

custom_components/renpho_fitness_scale_ble/config_flow.py

@@ -342,6 +342,9 @@ class ScaleConfigFlow(ConfigFlow, domain=DOMAIN):
     """Renpho scale config flow."""
 
     VERSION = 1
+    # minor_version 2: battery entity disabled by default (see
+    # async_migrate_entry). New entries start here; older entries migrate up.
+    MINOR_VERSION = 2
 
     def __init__(self) -> None:
         self._discovered_devices: dict[str, Discovery] = {}

custom_components/renpho_fitness_scale_ble/coordinator.py

@@ -1358,20 +1358,31 @@ def _on_scale_data(self, data: ScaleData) -> None:
         )
         # Decide which user this measurement is for.
         # - multi-user mode: the async resolver may have already picked one,
-        #   in which case `_last_resolved_user_id` is set.
+        #   in which case `_last_resolved_user_id` is set. Otherwise, try to
+        #   resolve and if there's still no clear winner, treat as pending.
         # - fixed-user / weight-only mode (1 configured user): the library
         #   doesn't call our resolver at all, but the answer is unambiguous —
         #   route to the only user.
-        # - otherwise: store as pending and fire the ambiguous-notification flow.
         user_id = self._last_resolved_user_id
         self._last_resolved_user_id = None
-        if user_id is None and len(self._user_profiles) == 1:
-            user_id = self._user_profiles[0][CONF_USER_ID]
+
+        candidate_ids: list[str] | None = None
+        if user_id is None:
+            if len(self._user_profiles) == 1:
+                user_id = self._user_profiles[0][CONF_USER_ID]
+            else:
+                candidate_ids = self._compute_pending_candidates(measurement.weight_kg)
+                if len(candidate_ids) == 1:
+                    user_id = candidate_ids[0]
 
         if user_id is not None:
             self._commit_measurement_to_user(user_id, measurement, data)
         else:
-            self._add_pending_measurement(measurement, data)
+            # Reuse the candidate list already computed above (if any) so we
+            # don't run the router a second time for the same measurement.
+            self._add_pending_measurement(
+                measurement, data, candidate_ids=candidate_ids
+            )
 
         # Push firmware revision into the device registry (no-op until the
         # library reads it; harmless to call repeatedly).
@@ -1590,10 +1601,17 @@ def _maybe_compute_bmi(self, data: ScaleData, user_id: str) -> None:
         )
 
     def _add_pending_measurement(
-        self, measurement: WeightMeasurement, data: ScaleData
+        self,
+        measurement: WeightMeasurement,
+        data: ScaleData,
+        candidate_ids: list[str] | None = None,
     ) -> None:
         """Store a measurement that wasn't attributed at weigh time.
 
+        ``candidate_ids`` may be passed by the caller when it has already
+        computed the candidate list (via ``_compute_pending_candidates``), so
+        the router isn't evaluated a second time for the same measurement.
+
         Triggers the ambiguous-notification flow (mobile push to candidate
         users + persistent notification) and keeps the measurement in
         ``_pending_measurements`` until either:
@@ -1605,7 +1623,8 @@ def _add_pending_measurement(
         # Opportunistic cleanup: drop any pending entries older than the
         # max age before adding the new one.
         self._cleanup_aged_pending_measurements()
-        candidate_ids = self._compute_pending_candidates(measurement.weight_kg)
+        if candidate_ids is None:
+            candidate_ids = self._compute_pending_candidates(measurement.weight_kg)
         timestamp_iso = measurement.timestamp.isoformat()
         # Reuse the measurement's pre-computed display string when present
         # (it always is for live measurements; falls back to a fresh render
@@ -1634,7 +1653,9 @@ def _add_pending_measurement(
         )
 
     def _compute_pending_candidates(self, weight_kg: float) -> list[str]:
-        """Return the same candidate list ``_resolve_user`` would have produced.
+        """Return the same candidate list ``_resolve_user`` would have produced,
+        but with added logic to fallback to all users if no candidates match
+        the weight.
 
         Used in the unresolved (weight-only) path to populate the pending
         record's ``candidates`` so we can mobile-notify those users.
@@ -1650,9 +1671,30 @@ def _compute_pending_candidates(self, weight_kg: float) -> list[str]:
             ranked = self._router.evaluate_measurement(synthetic)
         except Exception:
             _LOGGER.exception("Router evaluation failed in pending-candidate compute")
-            return []
+            ranked = []
         candidate_ids = [c.user_id for c in ranked]
-        return self._filter_candidates_by_location(candidate_ids)
+        filtered_candidates = self._filter_candidates_by_location(candidate_ids)
+        if filtered_candidates:
+            return filtered_candidates
+        if candidate_ids:
+            return candidate_ids
+
+        # Fallback: if no candidates match weight, include all users
+        all_user_ids = [
+            u[CONF_USER_ID] for u in self._user_profiles if CONF_USER_ID in u
+        ]
+        if not all_user_ids:
+            return []
+
+        filtered_all = self._filter_candidates_by_location(all_user_ids)
+        if filtered_all:
+            return filtered_all
+
+        _LOGGER.debug(
+            "No pending candidates found for weight %.2f kg, falling back to all configured users",
+            weight_kg,
+        )
+        return all_user_ids
 
     def _update_config_entry(self) -> None:
         """Persist coordinator state to the config entry's data dict.

custom_components/renpho_fitness_scale_ble/manifest.json

@@ -36,7 +36,7 @@
   "issue_tracker": "https://github.com/ronnnnnnnnnnnnn/renpho_fitness_scale_ble/issues",
   "requirements": [
     "renpho-escs20m==0.3.0",
-    "multi-user-scale-core==0.1.1"
+    "multi-user-scale-core==0.1.2"
   ],
-  "version": "0.2.1"
+  "version": "0.2.2"
 }

custom_components/renpho_fitness_scale_ble/sensor.py

@@ -159,6 +159,7 @@ def _handle_update(self, data: ScaleData) -> None:
         else:
             self._attr_available = True
             self._attr_native_value = value
+            self._attr_force_update = True
         self.async_write_ha_state()
 
 
@@ -211,6 +212,13 @@ class ScaleBatterySensor(RestoreSensor):
     _attr_native_unit_of_measurement = PERCENTAGE
     _attr_state_class = SensorStateClass.MEASUREMENT
     _attr_name = "Battery"
+    # Disabled by default: the ES-CS20M / QN-series firmware reports a static
+    # 100% on the standard Battery Level characteristic and does not decrement
+    # it as the cells drain, so a first-class battery entity would mislead users
+    # and never fire low-battery automations. Users whose hardware happens to
+    # report a real value (or who want the raw reading) can opt in by enabling
+    # the entity. The value also remains available in the diagnostics download.
+    _attr_entity_registry_enabled_default = False
 
     def __init__(
         self,

requirements.txt

@@ -1,3 +1,3 @@
 renpho-escs20m==0.3.0
-multi-user-scale-core==0.1.1
+multi-user-scale-core==0.1.2
 ruff==0.6.2