feat: Centralized mobile notification system (v1.3.0)

This release introduces a comprehensive mobile notification system that sends push notifications to users' mobile devices for key events.

## New Features

### 📱 Mobile Notification System
- **MobileNotificationService**: Centralized service for sending mobile notifications
- **Configuration Step**: Added notifications step in onboarding wizard
- **Granular Control**: 3 switches to enable/disable notifications per feature:
  - `evsc_notify_smart_blocker_enabled` - Smart Blocker notifications (default ON)
  - `evsc_notify_priority_balancer_enabled` - Priority Balancer notifications (default ON)
  - `evsc_notify_night_charge_enabled` - Night Charge notifications (default ON)

### 🔔 Notification Types
1. **Smart Blocker** - Charging interrupted outside window
   - Emoji-rich Italian message with timestamp
   - Includes blocking reason

2. **Priority Balancer** - Priority changes (EV ↔ Home ↔ EV_Free)
   - Shows current and target SOC for both EV and Home battery
   - Explains reason for priority change

3. **Night Smart Charge** - Charging started (battery/grid mode)
   - Distinguishes between battery and grid mode
   - Includes PV forecast and charging amperage
   - Explains reason for mode selection

### 📋 Technical Details
- **Title**: All notifications use fixed title "BORGO"
- **Tags**: Grouped by feature (evsc_smart_blocker, evsc_priority_change, evsc_night_charge)
- **Priority Levels**: High for Smart Blocker, normal for others
- **Icon**: All use mdi:ev-station
- **Service Discovery**: Runtime discovery of mobile_app_* notify services
- **Backward Compatibility**: Graceful handling for existing installations without notification config

## Files Modified/Created

### NEW
- `utils/mobile_notification_service.py` (212 lines) - Centralized notification service

### MODIFIED
- `const.py` - Added CONF_NOTIFY_SERVICES and notification switch suffixes
- `config_flow.py` - Added step 5 (notifications) to both config and options flow
- `switch.py` - Added 3 notification control switches
- `strings.json` - Added Italian translations for notifications step
- `automations.py` - Integrated mobile notifications in Smart Blocker
- `priority_balancer.py` - Added priority change detection and notifications
- `night_smart_charge.py` - Added notifications when charging starts (battery/grid mode)
- `__init__.py` - Updated version to 1.3.0
- `manifest.json` - Updated version to 1.3.0

## Integration Architecture
- Config flow passes `CONF_NOTIFY_SERVICES` list to all components
- Each component initializes MobileNotificationService with notify services list
- Notifications respect enabled/disabled switches via entity registry lookup
- Default behavior: All notification switches ON for new installations

## Testing Recommendations
1. Complete onboarding with mobile device selection
2. Verify 3 notification switches created and enabled by default
3. Test Smart Blocker notification when charging blocked
4. Test Priority Balancer notification on priority changes
5. Test Night Charge notifications for both battery and grid modes
6. Verify notifications arrive on selected mobile devices
7. Test disabling individual notification switches

🚀 Generated with Claude Code

Author: Antonio ...

custom_components/ev_smart_charger/__init__.py

@@ -23,7 +23,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     hass.data.setdefault(DOMAIN, {})
 
     _LOGGER.info("=" * 64)
-    _LOGGER.info("🚗 EV Smart Charger v1.2.1 - Starting setup")
+    _LOGGER.info("🚗 EV Smart Charger v1.3.0 - Starting setup")
     _LOGGER.info("=" * 64)
 
     # ========== PHASE 1: SETUP PLATFORMS (Helper Entities) ==========
@@ -120,7 +120,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     entry.async_on_unload(entry.add_update_listener(_reload_on_update))
 
     _LOGGER.info("=" * 64)
-    _LOGGER.info("✅ EV Smart Charger v1.2.1 - Setup completed successfully!")
+    _LOGGER.info("✅ EV Smart Charger v1.3.0 - Setup completed successfully!")
     _LOGGER.info("=" * 64)
 
     return True

custom_components/ev_smart_charger/automations.py

@@ -12,6 +12,7 @@
     DOMAIN,
     CONF_EV_CHARGER_SWITCH,
     CONF_EV_CHARGER_STATUS,
+    CONF_NOTIFY_SERVICES,
     CHARGER_STATUS_CHARGING,
     HELPER_NIGHT_CHARGE_TIME_SUFFIX,
     SMART_BLOCKER_ENFORCEMENT_TIMEOUT,
@@ -24,6 +25,7 @@
 from .utils.state_helper import get_state
 from .utils.entity_registry_service import EntityRegistryService
 from .utils.notification_service import NotificationService
+from .utils.mobile_notification_service import MobileNotificationService
 from .utils.astral_time_service import AstralTimeService
 from .utils.time_parsing_service import TimeParsingService
 
@@ -62,6 +64,9 @@ def __init__(
         self.logger = EVSCLogger("SMART BLOCKER")
         self._registry_service = EntityRegistryService(hass, entry_id)
         self._notification_service = NotificationService(hass)
+        self._mobile_notifier = MobileNotificationService(
+            hass, config.get(CONF_NOTIFY_SERVICES, []), entry_id
+        )
         self._astral_service = AstralTimeService(hass)
 
         # Listeners
@@ -516,6 +521,9 @@ async def _block_charging(self, reason: str) -> None:
                 }
             )
 
+            # Send mobile notification
+            await self._mobile_notifier.send_smart_blocker_notification(reason)
+
             self.logger.separator()
 
         except Exception as e:

custom_components/ev_smart_charger/config_flow.py

@@ -17,6 +17,7 @@
     CONF_HOME_CONSUMPTION,
     CONF_GRID_IMPORT,
     CONF_PV_FORECAST,
+    CONF_NOTIFY_SERVICES,
 )
 
 class EVSCConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
@@ -117,10 +118,9 @@ async def async_step_pv_forecast(self, user_input: dict[str, Any] | None = None)
         errors = {}
 
         if user_input is not None:
-            # Merge all data and create entry
-            data = {**self.init_info, **self.charger_info, **self.sensor_info, **user_input}
-            title = self.init_info.get(CONF_NAME, DEFAULT_NAME)
-            return self.async_create_entry(title=title, data=data)
+            # Store PV forecast info and move to notifications step
+            self.pv_forecast_info = user_input
+            return await self.async_step_notifications()
 
         schema = vol.Schema({
             vol.Optional(CONF_PV_FORECAST): selector.EntitySelector(
@@ -134,10 +134,59 @@ async def async_step_pv_forecast(self, user_input: dict[str, Any] | None = None)
             errors=errors,
             description_placeholders={
                 "step": "4",
-                "total_steps": "4"
+                "total_steps": "5"
             }
         )
 
+    async def async_step_notifications(self, user_input: dict[str, Any] | None = None):
+        """Handle mobile notification services selection step."""
+        errors = {}
+
+        if user_input is not None:
+            # Merge all data and create entry
+            data = {
+                **self.init_info,
+                **self.charger_info,
+                **self.sensor_info,
+                **self.pv_forecast_info,
+                **user_input
+            }
+            title = self.init_info.get(CONF_NAME, DEFAULT_NAME)
+            return self.async_create_entry(title=title, data=data)
+
+        # Discover available mobile notify services
+        notify_services = self._get_mobile_notify_services()
+
+        schema = vol.Schema({
+            vol.Optional(CONF_NOTIFY_SERVICES, default=[]): selector.SelectSelector(
+                selector.SelectSelectorConfig(
+                    options=notify_services,
+                    multiple=True,
+                    mode=selector.SelectSelectorMode.DROPDOWN
+                )
+            ),
+        })
+
+        return self.async_show_form(
+            step_id="notifications",
+            data_schema=schema,
+            errors=errors,
+            description_placeholders={
+                "step": "5",
+                "total_steps": "5"
+            }
+        )
+
+    def _get_mobile_notify_services(self) -> list[str]:
+        """Get list of available mobile_app notify services."""
+        notify_services = self.hass.services.async_services().get("notify", {})
+        mobile_services = [
+            service
+            for service in notify_services.keys()
+            if service.startswith("mobile_app_")
+        ]
+        return mobile_services if mobile_services else []
+
     @staticmethod
     @callback
     def async_get_options_flow(config_entry):
@@ -247,12 +296,9 @@ async def async_step_sensors(self, user_input: dict[str, Any] | None = None):
     async def async_step_pv_forecast(self, user_input: dict[str, Any] | None = None):
         """Manage PV forecast entity options (optional)."""
         if user_input is not None:
-            # Merge all data and update entry
-            data = {**self.config_entry.data, **self.charger_info, **self.sensor_info, **user_input}
-            self.hass.config_entries.async_update_entry(
-                self.config_entry, data=data
-            )
-            return self.async_create_entry(title="", data={})
+            # Store PV forecast info and move to notifications step
+            self.pv_forecast_info = user_input
+            return await self.async_step_notifications()
 
         # Get current values
         current_data = self.config_entry.data
@@ -271,6 +317,58 @@ async def async_step_pv_forecast(self, user_input: dict[str, Any] | None = None)
             data_schema=schema,
             description_placeholders={
                 "step": "3",
-                "total_steps": "3"
+                "total_steps": "4"
+            }
+        )
+
+    async def async_step_notifications(self, user_input: dict[str, Any] | None = None):
+        """Manage mobile notification services options."""
+        if user_input is not None:
+            # Merge all data and update entry
+            data = {
+                **self.config_entry.data,
+                **self.charger_info,
+                **self.sensor_info,
+                **self.pv_forecast_info,
+                **user_input
+            }
+            self.hass.config_entries.async_update_entry(
+                self.config_entry, data=data
+            )
+            return self.async_create_entry(title="", data={})
+
+        # Get current values
+        current_data = self.config_entry.data
+        notify_services = self._get_mobile_notify_services()
+
+        schema = vol.Schema({
+            vol.Optional(
+                CONF_NOTIFY_SERVICES,
+                default=current_data.get(CONF_NOTIFY_SERVICES, [])
+            ): selector.SelectSelector(
+                selector.SelectSelectorConfig(
+                    options=notify_services,
+                    multiple=True,
+                    mode=selector.SelectSelectorMode.DROPDOWN
+                )
+            ),
+        })
+
+        return self.async_show_form(
+            step_id="notifications",
+            data_schema=schema,
+            description_placeholders={
+                "step": "4",
+                "total_steps": "4"
             }
         )
+
+    def _get_mobile_notify_services(self) -> list[str]:
+        """Get list of available mobile_app notify services."""
+        notify_services = self.hass.services.async_services().get("notify", {})
+        mobile_services = [
+            service
+            for service in notify_services.keys()
+            if service.startswith("mobile_app_")
+        ]
+        return mobile_services if mobile_services else []

custom_components/ev_smart_charger/const.py

@@ -2,7 +2,7 @@
 
 # ========== INTEGRATION METADATA ==========
 DOMAIN = "ev_smart_charger"
-VERSION = "1.2.1"
+VERSION = "1.3.0"
 DEFAULT_NAME = "EV Smart Charger"
 
 # ========== PLATFORMS ==========
@@ -59,6 +59,9 @@
 CONF_GRID_IMPORT = "grid_import"
 CONF_PV_FORECAST = "pv_forecast"
 
+# Mobile Notifications
+CONF_NOTIFY_SERVICES = "notify_services"
+
 # ========== HELPER ENTITY SUFFIXES ==========
 
 # Switches
@@ -68,6 +71,11 @@
 HELPER_PRIORITY_BALANCER_ENABLED_SUFFIX = "evsc_priority_balancer_enabled"
 HELPER_NIGHT_CHARGE_ENABLED_SUFFIX = "evsc_night_smart_charge_enabled"
 
+# Notification Switches
+HELPER_NOTIFY_SMART_BLOCKER_SUFFIX = "evsc_notify_smart_blocker_enabled"
+HELPER_NOTIFY_PRIORITY_BALANCER_SUFFIX = "evsc_notify_priority_balancer_enabled"
+HELPER_NOTIFY_NIGHT_CHARGE_SUFFIX = "evsc_notify_night_charge_enabled"
+
 # Numbers - Solar Surplus
 HELPER_CHECK_INTERVAL_SUFFIX = "evsc_check_interval"
 HELPER_GRID_IMPORT_THRESHOLD_SUFFIX = "evsc_grid_import_threshold"

custom_components/ev_smart_charger/manifest.json

@@ -1,7 +1,7 @@
 {
   "domain": "ev_smart_charger",
   "name": "EV Smart Charger",
-  "version": "1.2.1",
+  "version": "1.3.0",
   "documentation": "https://github.com/antbald/ha-ev-smart-charger",
   "issue_tracker": "https://github.com/antbald/ha-ev-smart-charger/issues",
   "codeowners": ["@antbald"],

custom_components/ev_smart_charger/night_smart_charge.py

@@ -10,6 +10,7 @@
     CONF_EV_CHARGER_STATUS,
     CONF_SOC_HOME,
     CONF_PV_FORECAST,
+    CONF_NOTIFY_SERVICES,
     CHARGER_STATUS_FREE,
     NIGHT_CHARGE_MODE_BATTERY,
     NIGHT_CHARGE_MODE_GRID,
@@ -22,6 +23,7 @@
 )
 from .utils.logging_helper import EVSCLogger
 from .utils import entity_helper, state_helper
+from .utils.mobile_notification_service import MobileNotificationService
 from .utils.astral_time_service import AstralTimeService
 from .utils.time_parsing_service import TimeParsingService
 
@@ -54,6 +56,9 @@ def __init__(
         self.charger_controller = charger_controller
         self.logger = EVSCLogger("NIGHT SMART CHARGE")
         self._astral_service = AstralTimeService(hass)
+        self._mobile_notifier = MobileNotificationService(
+            hass, config.get(CONF_NOTIFY_SERVICES, []), entry_id
+        )
 
         # User-configured entities
         self._charger_status = config.get(CONF_EV_CHARGER_STATUS)
@@ -327,25 +332,26 @@ async def _evaluate_and_charge(self) -> None:
                 "BATTERY MODE",
                 f"Good solar forecast ({pv_forecast} kWh >= {threshold} kWh)"
             )
-            await self._start_battery_charge()
+            await self._start_battery_charge(pv_forecast)
         else:
             self.logger.decision(
                 "Charging mode",
                 "GRID MODE",
                 f"Low/no solar forecast ({pv_forecast} kWh < {threshold} kWh)"
             )
-            await self._start_grid_charge()
+            await self._start_grid_charge(pv_forecast)
 
     # ========== BATTERY CHARGE MODE ==========
 
-    async def _start_battery_charge(self) -> None:
+    async def _start_battery_charge(self, pv_forecast: float) -> None:
         """Start charging using home battery at configured amperage with continuous monitoring."""
         self.logger.separator()
         self.logger.start(f"{self.logger.BATTERY} Battery charge mode")
 
         amperage = self._get_night_charge_amperage()
         home_min_soc = self._get_home_battery_min_soc()
         ev_target = self.priority_balancer.get_ev_target_for_today()
+        threshold = self._get_solar_threshold()
 
         self.logger.info(f"   Charger amperage: {amperage}A")
         self.logger.info(f"   EV target SOC: {ev_target}%")
@@ -358,6 +364,15 @@ async def _start_battery_charge(self) -> None:
         self._night_charge_active = True
         self._active_mode = NIGHT_CHARGE_MODE_BATTERY
 
+        # Send mobile notification
+        reason = f"Previsione solare sufficiente ({pv_forecast:.1f} kWh >= {threshold} kWh)"
+        await self._mobile_notifier.send_night_charge_notification(
+            mode=NIGHT_CHARGE_MODE_BATTERY,
+            reason=reason,
+            amperage=amperage,
+            forecast=pv_forecast
+        )
+
         # Start continuous battery monitoring (every 1 minute)
         if self._battery_monitor_unsub:
             self._battery_monitor_unsub()  # Cancel existing monitor if any
@@ -425,13 +440,14 @@ async def _async_monitor_battery_charge(self, now) -> None:
 
     # ========== GRID CHARGE MODE ==========
 
-    async def _start_grid_charge(self) -> None:
+    async def _start_grid_charge(self, pv_forecast: float) -> None:
         """Start charging from grid at configured amperage."""
         self.logger.separator()
         self.logger.start(f"{self.logger.GRID} Grid charge mode")
 
         amperage = self._get_night_charge_amperage()
         ev_target = self.priority_balancer.get_ev_target_for_today()
+        threshold = self._get_solar_threshold()
 
         self.logger.info(f"   Charger amperage: {amperage}A")
         self.logger.info(f"   EV target SOC: {ev_target}%")
@@ -443,6 +459,15 @@ async def _start_grid_charge(self) -> None:
         self._night_charge_active = True
         self._active_mode = NIGHT_CHARGE_MODE_GRID
 
+        # Send mobile notification
+        reason = f"Previsione solare insufficiente ({pv_forecast:.1f} kWh < {threshold} kWh)"
+        await self._mobile_notifier.send_night_charge_notification(
+            mode=NIGHT_CHARGE_MODE_GRID,
+            reason=reason,
+            amperage=amperage,
+            forecast=pv_forecast
+        )
+
         self.logger.success("Grid charge started successfully")
         self.logger.info(f"Will charge until EV reaches target SOC ({ev_target}%)")
         self.logger.info("Grid import detection is disabled for night charging")