Merge pull request #131 from mudape/vidare

Tuning

Author: mudape

README.md

@@ -1,44 +1,94 @@
-[![hacs_badge](https://img.shields.io/badge/HACS-Default-orange.svg)](https://github.com/custom-components/hacs) 
-![GitHub release](https://img.shields.io/github/release/mudape/iphonedetect.svg)
-# iPhone Detect
-This integration sends a message to the defined hosts on UDP port 5353.  
-The iPhone responds, _even when in deep sleep_, and an entry in the ARP cache is made .  
+# iPhone Detect for Home-Assistant
 
-Uses Home Assistant's [device_tracker](https://www.home-assistant.io/components/device_tracker/) and idea/script from [return01](https://community.home-assistant.io/u/return01)
+[![Validate with hassfest](https://github.com/mudape/iphonedetect/actions/workflows/hassfest.yaml/badge.svg)](https://github.com/mudape/iphonedetect/actions/workflows/hassfest.yaml)
+[![HACS Validate](https://github.com/mudape/iphonedetect/actions/workflows/hacs_action.yml/badge.svg)](https://github.com/mudape/iphonedetect/actions/workflows/hacs_action.yml)
+[![hacs_badge](https://img.shields.io/badge/HACS-Default-blue.svg)](https://github.com/custom-components/hacs)
 
-Only **IP addresses** will work, _no hostnames_!  
-You have to assign a **static** IP address(es) to your iPhones, probably in your router. 
+![downloads](https://img.shields.io/github/downloads/mudape/iphonedetect/total.svg)
+![downloads](https://img.shields.io/github/downloads/mudape/iphonedetect/1.4.2/total.svg)
+![downloads](https://img.shields.io/github/downloads/mudape/iphonedetect/latest/total.svg)
 
-_The interval_seconds time must be shorter than the timeout in which the ARP cache is cleared (usally 15-45sec), or the phone will be marked not_home._
-_So, leave it at the default value (12sec) or make it shorter._
+This integration sends a mDNS message to defined hosts.  
+The device responds if it's connected to the network, even when in deep sleep, and an entry in the ARP cache is made and read.  
+Usefull as a [device_tracker](https://www.home-assistant.io/integrations/device_tracker/) for your [person](https://www.home-assistant.io/integrations/person/) integration to see if users are at home.
 
-<a href="https://www.buymeacoffee.com/MudApe" target="_blank"><img src="https://www.buymeacoffee.com/assets/img/custom_images/orange_img.png" alt="Buy Me A Coffee" style="height: auto !important;width: auto !important;" ></a>
+## Installation
+
+After installation you need to **restart** Home-Assistant before using the integration.
+
+### Using HACS  
+
+If you dont' have [HACS](https://hacs.xyz) installed yet, I highly recommend it.  
+[![Open your Home Assistant instance and open a repository inside the Home Assistant Community Store.](https://my.home-assistant.io/badges/hacs_repository.svg)](https://my.home-assistant.io/redirect/hacs_repository/?owner=mudape&repository=iphonedetect&category=integration) or search for `iPhone Device Tracker`.
+
+### Manual  
+
+Download the `iphonedetect` directory and place in your `<config>/custom_component`
+
+## Configuration  
+
+### Network
+
+Assign a **static** IP address to the device you want to track, probably in your router.  
+Alternative, set a manual IP in your device WiFi configuration.  
+Avoid automatically connect to differtent SSID's (2.4 and 5 ghz bands)  
+
+### Setup
+
+[![Open your Home Assistant instance and start setting up a new integration.](https://my.home-assistant.io/badges/config_flow_start.svg)](https://my.home-assistant.io/redirect/config_flow_start/?domain=iphonedetect)
+
+If you don't have [My Home Assistant](https://my.home-assistant.io/) redirects set up, go to Settings -> Devices & Services  
+Click "Add integration" and search for `iPhone Device Tracker`
+
+Give the entity a unique `name` and enter its IP address.  
+
+![image](https://github.com/user-attachments/assets/c4583955-72d8-4c3a-81b4-062a134af11e)
 
-## Example configuration.yaml
-
-```yaml
-device_tracker:
-  - platform: iphonedetect
-    consider_home: 60
-    scan_interval: 12
-    new_device_defaults:
-      track_new_devices: true
-    hosts:
-      hostname1: 192.168.0.17
-      hostname2: 192.168.0.24
-```
-This will create `device_tracker.hostname1` and `device_tracker.hostname2` once the devices have been detected on your network.  
-(Re)start the Wi-Fi on your device/phone to trigger their creation on first run. 
-
-__Note__  
-If you have `track_new_devices: false` (in this or any integrations specified before this) for the device_tracker component you need to manually change `track:` to true for each device in `known_devices.yaml`  
-(see component settings for [device_tracker](https://www.home-assistant.io/components/device_tracker/#configuring-a-device_tracker-platform))  
-```yaml
-hostname1:
-  icon:
-  mac:
-  name: hostname1
-  picture:
-  track: true
-```
+This will create an entity `device_tracker.<name>`  
 
+Repeat the steps for additional entities.
+
+#### Options
+
+You can change the consider home timeout per tracked device in the UI.  
+Default is 24 seconds.  
+![image](https://github.com/user-attachments/assets/caf31775-333d-448c-b8f2-660534d856d7)
+
+#### Reconfigure
+
+You can change the IP address of the tracked device in the UI.  
+![image](https://github.com/user-attachments/assets/4fc98224-eee6-4451-aaf1-b16c858014d2)
+
+## Troubleshooting | FAQ  
+
+<details>
+<summary>Private Wi-Fi address</summary>
+The device private MAC address will remain the same for each network, as long as the network isn't recreated or rotating (iOS 18+) MAC is used.  
+
+In other words, if a tracked device no longer can be found the user have propably recreated the connection to your Wi-Fi forcing a new random MAC address to be used.  
+<br />
+Note that if your WiFi has different SSID for the 2.4 and 5 ghz bands, and the phone has private network enabled, two different MAC will be presented to the DHCP.  
+Most likely that will require the integration to track two IP's per user/Person.
+<br />
+So, for best result only have/connect to one SSID, turn off private network and assign static IP.
+</details>
+<details>
+<summary>False or flaky not_home status</summary>
+Especially when the network has multiple Access Points, tracked devices sometimes are marked as not_home when actually connected to the network.  
+Increasing the consider home timeout might help this.  
+Most likely it's a network issue though, try placing your AP's at different locations.  
+
+Devices might auto-update during night, they of course then will be not_home for awhile.  
+</details>
+
+## Attribution
+
+Original idea from [return01](https://community.home-assistant.io/u/return01)
+
+## Disclaimer  
+
+Author is in no way affiliated with Apple Inc.  
+Author does not guarantee functionality of this integration and is not responsible for any damage.  
+All product names, trademarks and registered trademarks in this repository, are property of their respective owners.  
+
+<a href="https://www.buymeacoffee.com/MudApe" target="_blank"><img src="https://www.buymeacoffee.com/assets/img/custom_images/orange_img.png" alt="Buy Me A Coffee" style="height: auto !important;width: auto !important;" ></a>

custom_components/iphonedetect/config_flow.py

@@ -14,13 +14,16 @@
     ConfigEntry,
     ConfigFlow,
     FlowResult,
-    OptionsFlow,
 )
 from homeassistant.const import (
     CONF_IP_ADDRESS,
     CONF_NAME,
 )
 from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers.schema_config_entry_flow import (
+    SchemaFlowFormStep,
+    SchemaOptionsFlowHandler,
+)
 from homeassistant.util import slugify
 
 from .const import (
@@ -30,28 +33,31 @@
     MIN_CONSIDER_HOME,
 )
 
-_LOGGER = logging.getLogger(__name__)
-
 
-async def validate_ip_address(subnets: list[IPv4Network], devices: list, ip: str) -> dict:
-    """Try to validate user input"""
-    errors = {}
+_LOGGER = logging.getLogger(__name__)
 
-    if ip in devices:
-        errors["base"] = "ip_already_configured"
 
-    if not errors:
-        try:
-            ip_address = IPv4Address(ip)
-        except AddressValueError:
-            errors["base"] = "ip_invalid"
-            return errors
+OPTIONS_SCHEMA = vol.Schema(
+    {
+        vol.Required(CONF_CONSIDER_HOME, default=DEFAULT_CONSIDER_HOME): vol.All(
+            vol.Coerce(int),
+            vol.Range(min=MIN_CONSIDER_HOME, max=MAX_CONSIDER_HOME),
+        )
+    }
+)
 
-    if not errors:
-        if not any(ip_address in subnet for subnet in subnets):
-            errors["base"] = "ip_range"
+DATA_SCHEMA = vol.Schema(
+    {
+        vol.Required(CONF_NAME, description={"suggested_value": "My iPhone"}): str,
+        vol.Required(CONF_IP_ADDRESS, description={"suggested_value": "192.168.1.xx"}): str,
+        **OPTIONS_SCHEMA.schema,
+        vol.Optional("subnet_check", default=True): bool,
+    }
+)
 
-    return errors
+OPTIONS_FLOW = {
+    "init": SchemaFlowFormStep(OPTIONS_SCHEMA),
+}
 
 
 async def async_get_networks(hass: HomeAssistant) -> list[IPv4Network]:
@@ -68,81 +74,72 @@ async def async_get_networks(hass: HomeAssistant) -> list[IPv4Network]:
     return networks
 
 
-class IphoneDetectOptionsFlowHandler(OptionsFlow):
-    """iPhone Detect config flow options handler."""
-
-    async def async_step_init(self, user_input: dict[str, Any] | None = None) -> FlowResult:
-        """Manage the options."""
-        return await self.async_step_user(user_input)
-
-    async def async_step_user(self, user_input: dict[str, Any] | None = None) -> FlowResult:
-        """Handle options flow."""
-        errors = {}
-
-        if user_input is not None and user_input[CONF_CONSIDER_HOME] != self.config_entry.options[CONF_CONSIDER_HOME]:
-            new_options = self.config_entry.options | {CONF_CONSIDER_HOME: user_input[CONF_CONSIDER_HOME]}
-            return self.async_create_entry(title="", data=new_options)
-
-        return self.async_show_form(
-            step_id="user",
-            data_schema=vol.Schema(
-                {
-                    vol.Required(
-                        CONF_CONSIDER_HOME,
-                        default=self.config_entry.options[CONF_CONSIDER_HOME],
-                    ): vol.All(
-                        vol.Coerce(int),
-                        vol.Range(min=MIN_CONSIDER_HOME, max=MAX_CONSIDER_HOME),
-                    ),
-                }
-            ),
-            errors=errors,
-        )
+async def _validate_input(hass: HomeAssistant, user_input: dict[str, Any]) -> dict[str, str] | None:
+    """Try to validate user input"""
+    entries = [entry for entry in hass.config_entries.async_entries(DOMAIN)]
+    ip = user_input[CONF_IP_ADDRESS]
+
+    # Check if name already used for a clearer error
+    if user_input.get(CONF_NAME, False):
+        entries_id = [entry.unique_id for entry in entries]
+        entry_id = f"{DOMAIN}_{slugify(user_input[CONF_NAME]).lower()}"
+        if entry_id in entries_id:
+            return {"base": "name_not_unique"}
+
+    # Check if valid IP address
+    try:
+        IPv4Address(ip)
+    except AddressValueError:
+        return {"base": "ip_invalid"}
+
+    # Check if IP address already used for a clearer error
+    entries_ip = [entry.options[CONF_IP_ADDRESS] for entry in entries]
+    if ip in entries_ip:
+        return {"base": "ip_already_configured"}
+
+    # Check if device IP will be seen by ARP
+    if user_input["subnet_check"]:
+        subnets = await async_get_networks(hass)
+        if not any(IPv4Address(ip) in subnet for subnet in subnets):
+            return {"base": "ip_range"}
 
 
 class IphoneDetectFlowHandler(ConfigFlow, domain=DOMAIN):  # type: ignore
     """Handle a config flow."""
 
     VERSION = 2
 
+    @staticmethod
+    @callback
+    def async_get_options_flow(config_entry: ConfigEntry) -> SchemaOptionsFlowHandler:
+        return SchemaOptionsFlowHandler(config_entry, OPTIONS_FLOW)
+
     async def async_step_user(self, user_input: dict[str, Any] | None = None) -> FlowResult:
         """Handle a flow initialized by the user."""
         errors = {}
 
         if user_input is not None:
-            ip = user_input[CONF_IP_ADDRESS]
-            devices = [dev.options[CONF_IP_ADDRESS] for dev in self.hass.config_entries.async_entries(DOMAIN)]
-            subnet = await async_get_networks(self.hass)
-
-            errors = await validate_ip_address(subnet, devices, ip)
+            errors = await _validate_input(self.hass, user_input)
 
             if not errors:
                 unique_id = slugify(user_input[CONF_NAME]).lower()
                 await self.async_set_unique_id(f"{DOMAIN}_{unique_id}")
                 self._abort_if_unique_id_configured()
 
                 self._async_abort_entries_match({CONF_NAME: user_input[CONF_NAME]})
+
                 return self.async_create_entry(
                     title=user_input[CONF_NAME],
                     data={},
                     options={
-                        CONF_IP_ADDRESS: ip,
+                        CONF_IP_ADDRESS: user_input[CONF_IP_ADDRESS],
                         CONF_CONSIDER_HOME: user_input[CONF_CONSIDER_HOME],
                     },
                 )
 
         return self.async_show_form(
             step_id="user",
-            data_schema=vol.Schema(
-                {
-                    vol.Required(CONF_NAME, description={"suggested_value": "My iPhone"}): str,
-                    vol.Required(CONF_IP_ADDRESS, description={"suggested_value": "192.168.1.xx"}): str,
-                    vol.Required(CONF_CONSIDER_HOME, default=DEFAULT_CONSIDER_HOME): vol.All(
-                        vol.Coerce(int),
-                        vol.Range(min=MIN_CONSIDER_HOME, max=MAX_CONSIDER_HOME),
-                    ),
-                }
-            ),
+            data_schema=self.add_suggested_values_to_schema(DATA_SCHEMA, user_input),
             errors=errors,
         )
 
@@ -167,38 +164,24 @@ async def async_step_import(self, import_config) -> FlowResult:
 
     async def async_step_reconfigure(self, user_input: dict[str, Any] | None = None) -> FlowResult:
         """Handle options flow."""
-        entry = self.hass.config_entries.async_get_entry(self.context["entry_id"])
-        assert entry
-
         errors = {}
-        if user_input is not None:
-            new_ip = user_input.get(CONF_IP_ADDRESS)
-            current_ip = entry.options[CONF_IP_ADDRESS]
-
-            if new_ip and new_ip != current_ip:
-                devices = [other_entry.options[CONF_IP_ADDRESS] for other_entry in self.hass.config_entries.async_entries(DOMAIN) if other_entry.entry_id != entry.entry_id]
-                subnets = await async_get_networks(self.hass)
+        entry = self._get_reconfigure_entry()
 
-                errors = await validate_ip_address(subnets, devices, new_ip)
+        if user_input is not None:
+            errors = await _validate_input(self.hass, user_input)
+            if not errors:
+                await self.async_set_unique_id(entry.unique_id)
+                self._abort_if_unique_id_mismatch()
+                new_options = entry.options | {CONF_IP_ADDRESS: user_input[CONF_IP_ADDRESS]}
 
-                if not errors:
-                    new_options = entry.options | {
-                        CONF_IP_ADDRESS: new_ip,
-                    }
-                    return self.async_update_reload_and_abort(entry, options=new_options, reason="reconfigure_successful")
+                return self.async_update_reload_and_abort(
+                    entry,
+                    options=new_options,
+                )
 
         return self.async_show_form(
             step_id="reconfigure",
-            data_schema=vol.Schema(
-                {
-                    vol.Required(CONF_IP_ADDRESS, default=entry.options[CONF_IP_ADDRESS]): str,
-                }
-            ),
+            data_schema=vol.Schema({vol.Required(CONF_IP_ADDRESS, default=entry.options[CONF_IP_ADDRESS]): str, vol.Optional("subnet_check", default=True): bool}),
             description_placeholders={"device_name": entry.title},
             errors=errors,
         )
-
-    @staticmethod
-    @callback
-    def async_get_options_flow(config_entry: ConfigEntry) -> IphoneDetectOptionsFlowHandler:
-        return IphoneDetectOptionsFlowHandler()