chore(release): v1.1.2

При выключении switch запись полностью останавливается и не продолжается
При активации force_stop запись мгновенно останавливается и блокируется до деактивации
При деактивации force_stop система возвращается в нормальный режим

.gitea/workflows/update_version.yml

@@ -0,0 +1,69 @@
+name: Update Version
+
+on:
+  push:
+    branches:
+      - main
+      - master
+
+env:
+  GIT_SSL_NO_VERIFY: true
+
+jobs:
+  update-version:
+    name: Update Version
+    runs-on: ubuntu-latest
+    if: github.actor != 'gitea-actions[bot]' && github.actor != 'Gitea Actions Bot'
+    permissions:
+      contents: write
+    
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          token: ${{ secrets.PAT_TOKEN }}
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Install dependencies
+        run: pip install python-semantic-release
+
+      - name: Configure Git
+        run: |
+          git config --local user.email "actions@gitea.local"
+          git config --local user.name "Gitea Actions Bot"
+
+      - name: Run semantic-release
+        env:
+          GITEA_TOKEN: ${{ secrets.PAT_TOKEN }}
+        run: |
+          echo "🧹 Сбрасываем конфликтующие переменные Gitea Actions..."
+          unset GITHUB_SERVER_URL
+          unset GITHUB_API_URL
+          unset GITHUB_REPOSITORY
+
+          echo "🔐 Записываем оригинальный Root CA от mkcert из секретов..."
+          echo "${{ secrets.LOCAL_ROOT_CA }}" > /tmp/rootCA.crt
+
+          # Проверка на случай, если секрет забыли настроить
+          if [ ! -s /tmp/rootCA.crt ]; then
+            echo "❌ Ошибка: Секрет LOCAL_ROOT_CA пуст. Проверьте настройки репозитория!"
+            exit 1
+          fi
+
+          echo "✅ Root CA успешно прочитан."
+
+          # Находим, где конкретно Python (библиотека certifi) хранит свои сертификаты
+          CERTIFI_PATH=$(python3 -c "import certifi; print(certifi.where())")
+          echo "Путь к bundle Python: $CERTIFI_PATH"
+
+          # Внедряем корневой сертификат mkcert в конец доверенного списка Python
+          cat /tmp/rootCA.crt >> "$CERTIFI_PATH"
+          echo "✅ Root CA от mkcert добавлен в доверенные для Python!"
+
+          echo "🚀 Запускаем semantic-release..."
+          semantic-release version

.github/workflows/release.yml

@@ -0,0 +1,132 @@
+name: Test and Release
+
+on:
+  push:
+    tags:
+      - 'v*'
+  workflow_dispatch:  # Позволяет запускать вручную
+
+jobs:
+  # Шаг 1: Валидация структуры HA интеграции
+  validate:
+    name: Validate Integration
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Hassfest Validation
+        uses: home-assistant/actions/hassfest@master
+
+      - name: HACS Validation
+        uses: hacs/action@main
+        with:
+          category: "integration"
+
+  # Шаг 2: Запуск тестов (если есть)
+  test:
+    name: Run Tests
+    runs-on: ubuntu-latest
+    needs: validate
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install pytest pytest-homeassistant-custom-component
+          if [ -f requirements_test.txt ]; then pip install -r requirements_test.txt; fi
+
+      - name: Run tests
+        run: |
+          if [ -d "tests" ]; then
+            pytest tests/ --cov=custom_components/motion_light --cov-report=xml
+          else
+            echo "No tests directory found, skipping tests"
+          fi
+
+  # Шаг 3: Проверка стиля кода
+  lint:
+    name: Code Quality
+    runs-on: ubuntu-latest
+    needs: validate
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Install linters
+        run: |
+          pip install black ruff mypy
+
+      - name: Check code formatting with black
+        run: |
+          black --check custom_components/motion_light/ || echo "Code formatting issues found"
+
+      - name: Check code with ruff
+        run: |
+          ruff check custom_components/motion_light/ || echo "Ruff issues found"
+
+  # Шаг 4: Создание релиза (только если все проверки пройдены)
+  release:
+    name: Create Release
+    runs-on: ubuntu-latest
+    needs: [validate, test, lint]
+    permissions:
+      contents: write
+    
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Get tag info
+        id: tag
+        run: |
+          TAG=${GITHUB_REF#refs/tags/}
+          echo "tag=$TAG" >> $GITHUB_OUTPUT
+          
+          PREV_TAG=$(git describe --tags --abbrev=0 HEAD^ 2>/dev/null || echo "")
+          
+          if [ -z "$PREV_TAG" ]; then
+            COMMITS=$(git log --pretty=format:"- %s" --reverse)
+          else
+            COMMITS=$(git log ${PREV_TAG}..HEAD --pretty=format:"- %s" --reverse)
+          fi
+          
+          echo "commits<<EOF" >> $GITHUB_OUTPUT
+          echo "$COMMITS" >> $GITHUB_OUTPUT
+          echo "EOF" >> $GITHUB_OUTPUT
+
+      - name: Create GitHub Release
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          TAG="${{ steps.tag.outputs.tag }}"
+          COMMITS="${{ steps.tag.outputs.commits }}"
+          
+          echo "🚀 Создаём релиз $TAG в GitHub..."
+          
+          cat > /tmp/release_notes.md << EOF
+          ## Изменения в версии $TAG
+          
+          $COMMITS
+          EOF
+          
+          gh release create "$TAG" \
+            --title "Release $TAG" \
+            --notes-file /tmp/release_notes.md \
+            --target main
+          
+          echo "✅ Релиз создан!"

CHANGELOG.md

@@ -0,0 +1,26 @@
+# CHANGELOG
+
+<!-- version list -->
+
+## v1.1.2 (2026-07-11)
+
+### Bug Fixes
+
+- FST
+  ([`dc85e69`](https://192.168.200.208:3000/sirmrak/motion_recorder/commit/dc85e69e289cb2f13ddb0e51a98bfc207c73a9d6))
+
+
+## v1.1.1 (2026-07-10)
+
+### Bug Fixes
+
+- Оформление
+  ([`6ccca63`](https://192.168.200.208:3000/sirmrak/motion_recorder/commit/6ccca6327021b53a8cd46e62bb0d740f0a609043))
+
+
+## v1.1.0 (2026-07-05)
+
+
+## v1.0.0 (2026-07-03)
+
+- Initial Release

README.md

@@ -1,4 +1,4 @@
-# Motion Recorder for Home Assistant
+# <img src="custom_components/motion_recorder/brand/icon.png" width="64"> </img> Motion Recorder for Home Assistant
 English | [Русский](README.ru.md)
 
 ## A powerful Home Assistant integration for recording camera streams based on motion detection with advanced filtering and automated management.
@@ -19,6 +19,8 @@ English | [Русский](README.ru.md)
 -  **Force stop sensor** - Stop recording based on any entity state
 -  **Enable/disable switch** - Control recording with a toggle
 -  **Status sensor** - Monitor recording state with beautiful icons
+-  **Smart device control** - Automatically turn on/off lights or switches based on recording state
+-  **Auto-cleanup** - Delete old recordings by retention policy (daily at 03:00)
 -  **Multi-language support** - English and Russian translations
 -  **Hot reload** - Settings apply immediately without restart
 
@@ -66,6 +68,8 @@ When adding the integration, you'll configure:
 | **Force Stop Sensor** | Entity to force stop recording | - | - |
 | **Force Stop State** | State value to trigger stop | `off` | - |
 | **Retention Days** | Auto-delete recordings older than | 7 days | 0-365 days |
+| **Controlled Devices** | Lights/switches to auto-control | - | - |
+| **Control States** | States when devices should be ON | `recording` | Multi-select |
 | **Log Level** | Logging verbosity | INFO | - |
 
 ### Options (Post-Setup)
@@ -77,6 +81,8 @@ After initial setup, you can modify these settings via **Settings → Devices &
 - Motion filter
 - Off delay
 - Retention days
+- Controlled Devices
+- Control States
 - Log level
 
 Changes apply immediately without restart.
@@ -217,6 +223,29 @@ Files older than the retention period are automatically deleted daily at 03:00.
 
 Cleanup runs in the background and doesn't affect recording performance.
 
+## Smart Device Control
+
+Motion Recorder can automatically control lights and switches based on its current state.
+
+### How It Works
+
+1. Select one or more `light` or `switch` entities in settings
+2. Choose which states should trigger the devices (e.g., `recording`, `delaying`)
+3. When the integration enters a selected state → devices turn ON
+4. When it leaves that state → devices turn OFF (only if integration turned them on)
+
+### Safety Features
+
+- **Non-intrusive**: If you manually turn on a light, the integration won't turn it off
+- **Manual override respected**: If you turn off a controlled light during recording, it stays off
+- **Shutdown cleanup**: All integration-controlled devices are turned off when HA restarts or integration reloads
+
+### Example Use Cases
+
+- Turn on porch light only while recording is active
+- Activate alarm indicator LED during motion detection
+- Turn on indoor lighting when camera detects movement at night
+
 ## Advanced Features
 
 ### Multiple Motion Sensors
@@ -308,6 +337,6 @@ This project is licensed under the MIT License - see the LICENSE file for detail
 
 ---
 
-**Version**: 1.0.0  
+**Version**: 1.1.0  
-**Last Updated**: 2026-07-03  
+**Last Updated**: 2026-07-05  
 **Compatible with**: Home Assistant 2024.6+

README.ru.md

@@ -1,4 +1,4 @@
-# Motion Recorder для Home Assistant
+# <img src="custom_components/motion_recorder/brand/icon.png" width="64"> </img> Motion Recorder для Home Assistant
 [English](README.md) | Русский
 
 Мощная интеграция Home Assistant для записи камер по датчику движения с продвинутой фильтрацией и автоматическим управлением.
@@ -19,6 +19,8 @@
 - 🔌 **Датчик принудительной остановки** - Остановка записи по состоянию любой сущности
 - 🎛️ **Переключатель включения/выключения** - Управление записью одним кликом
 -  **Сенсор статуса** - Мониторинг состояния записи с красивыми иконками
+- 💡 **Умное управление устройствами** - Автоматическое включение/выключение света и переключателей по состоянию записи
+- 🗑️ **Автоочистка** - Удаление старых записей по политике хранения (ежедневно в 03:00)
 - 🌍 **Многоязычность** - Переводы на русский и английский языки
 -  **Горячая перезагрузка** - Настройки применяются сразу без перезапуска
 
@@ -66,6 +68,8 @@
 | **Датчик принуд. остановки** | Сущность для принудительной остановки | - | - |
 | **Состояние остановки** | Значение состояния для запуска остановки | `off` | - |
 | **Дни хранения** | Автоудаление записей старше | 7 дней | 0-365 дней |
+| **Управляемые устройства** | Светильники/переключатели для автоуправления | - | - |
+| **Состояния включения** | Состояния, при которых устройства включаются | `recording` | Множественный выбор |
 | **Уровень логирования** | Детализация логов | INFO | - |
 
 ### Опции (после настройки)
@@ -77,6 +81,8 @@
 - Фильтр движения
 - Задержка остановки
 - Дни хранения
+- Управляемые устройства
+- Состояния включения
 - Уровень логирования
 
 Изменения применяются сразу без перезапуска.
@@ -217,6 +223,29 @@ automation:
 
 Очистка работает в фоновом режиме и не влияет на производительность записи.
 
+## Умное управление устройствами
+
+Motion Recorder может автоматически управлять светильниками и переключателями в зависимости от текущего состояния.
+
+### Как это работает
+
+1. Выберите одну или несколько сущностей `light` или `switch` в настройках
+2. Отметьте состояния, при которых устройства должны включаться (например, `recording`, `delaying`)
+3. При переходе в выбранное состояние → устройства включаются
+4. При выходе из состояния → устройства выключаются (только если интеграция их включала)
+
+### Безопасность
+
+- **Не мешает пользователю**: Если вы вручную включили свет, интеграция его не выключит
+- **Ручное управление приоритетно**: Если вы выключили управляемый свет во время записи, он останется выключенным
+- **Очистка при остановке**: Все устройства, включённые интеграцией, выключаются при перезагрузке HA или перезагрузке интеграции
+
+### Примеры использования
+
+- Включать уличный фонарь только во время активной записи
+- Активировать индикатор тревоги при обнаружении движения
+- Включать освещение в помещении при детекции движения камерой ночью
+
 ## Продвинутые возможности
 
 ### Несколько датчиков движения
@@ -308,6 +337,6 @@ logger:
 
 ---
 
-**Версия**: 1.0.0  
+**Версия**: 1.1.0  
-**Последнее обновление**: 2026-07-03  
+**Последнее обновление**: 2026-07-05  
 **Совместимо с**: Home Assistant 2024.6+

custom_components/motion_recorder/__init__.py

@@ -11,9 +11,13 @@ _LOGGER = logging.getLogger(__name__)
 PLATFORMS = ["sensor", "switch"]
 
 
+def _get_config_value(entry: ConfigEntry, key: str, default=None):
+    """Get config value from options first, then from data, then default."""
+    return entry.options.get(key, entry.data.get(key, default))
+
+
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Set up Motion Recorder from a config entry."""
-    # Устанавливаем уровень логирования для всего домена
     log_level = _get_config_value(entry, CONF_LOG_LEVEL, DEFAULT_LOG_LEVEL)
     logging.getLogger(f"custom_components.{DOMAIN}").setLevel(getattr(logging, log_level, logging.INFO))
     _LOGGER.info("Motion Recorder integration loaded with log level: %s", log_level)
@@ -27,7 +31,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
 
-    # Добавляем listener для автоматической перезагрузки при изменении опций
     entry.async_on_unload(entry.add_update_listener(_async_update_listener))
 
     return True
@@ -50,8 +53,3 @@ async def _async_update_listener(hass: HomeAssistant, entry: ConfigEntry) -> Non
     """Handle options update - reload the integration."""
     _LOGGER.info("Options updated, reloading Motion Recorder integration")
     await hass.config_entries.async_reload(entry.entry_id)
-
-
-def _get_config_value(entry: ConfigEntry, key: str, default=None):
-    """Get config value from options first, then from data, then default."""
-    return entry.options.get(key, entry.data.get(key, default))

custom_components/motion_recorder/config_flow.py

@@ -18,6 +18,8 @@ from .const import (
     CONF_FORCE_STOP_STATE,
     CONF_LOG_LEVEL,
     CONF_RETENTION_DAYS,
+    CONF_CONTROLLED_ENTITIES,
+    CONF_CONTROL_STATES,
     DEFAULT_NAME,
     DEFAULT_SAVE_PATH,
     DEFAULT_FILENAME_TEMPLATE,
@@ -28,10 +30,16 @@ from .const import (
     DEFAULT_FORCE_STOP_STATE,
     DEFAULT_LOG_LEVEL,
     DEFAULT_RETENTION_DAYS,
+    DEFAULT_CONTROL_STATES,
+    STATE_IDLE,
+    STATE_DETECTING,
+    STATE_RECORDING,
+    STATE_DELAYING,
+    STATE_FINALIZING,
+    STATE_ERROR,
+    STATE_DISABLED,
 )
 
-
-# Список шаблонов имени файла (все с секундами для уникальности)
 FILENAME_TEMPLATE_OPTIONS = [
     selector.SelectOptionDict(value="%d-%m-%Y_%H-%M-%S", label="ДД-ММ-ГГГГ_ЧЧ-ММ-СС (02-07-2026_20-30-45)"),
     selector.SelectOptionDict(value="%Y-%m-%d_%H-%M-%S", label="ГГГГ-ММ-ДД_ЧЧ-ММ-СС (2026-07-02_20-30-45)"),
@@ -40,6 +48,16 @@ FILENAME_TEMPLATE_OPTIONS = [
     selector.SelectOptionDict(value="%d.%m.%Y_%H.%M.%S", label="ДД.ММ.ГГГГ_ЧЧ.ММ.СС (все точки)"),
 ]
 
+CONTROL_STATE_OPTIONS = [
+    selector.SelectOptionDict(value=STATE_IDLE, label="Ожидание (idle)"),
+    selector.SelectOptionDict(value=STATE_DETECTING, label="Обнаружение (detecting)"),
+    selector.SelectOptionDict(value=STATE_RECORDING, label="Запись (recording)"),
+    selector.SelectOptionDict(value=STATE_DELAYING, label="Задержка (delaying)"),
+    selector.SelectOptionDict(value=STATE_FINALIZING, label="Завершение (finalizing)"),
+    selector.SelectOptionDict(value=STATE_ERROR, label="Ошибка (error)"),
+    selector.SelectOptionDict(value=STATE_DISABLED, label="Отключено (disabled)"),
+]
+
 
 class MotionRecorderConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
     """Handle a config flow for Motion Recorder."""
@@ -104,13 +122,6 @@ class MotionRecorderConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
                         unit_of_measurement="сек",
                     )
                 ),
-                vol.Required(CONF_RETENTION_DAYS, default=DEFAULT_RETENTION_DAYS): selector.NumberSelector(
-                    selector.NumberSelectorConfig(
-                        min=0, max=365, step=1,
-                        mode=selector.NumberSelectorMode.SLIDER,
-                        unit_of_measurement="дн",
-                    )
-                ),
                 vol.Optional(CONF_FORCE_STOP_SENSOR): selector.EntitySelector(
                     selector.EntitySelectorConfig(
                         domain=["binary_sensor", "switch", "input_boolean"],
@@ -118,6 +129,26 @@ class MotionRecorderConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
                     )
                 ),
                 vol.Required(CONF_FORCE_STOP_STATE, default=DEFAULT_FORCE_STOP_STATE): str,
+                vol.Required(CONF_RETENTION_DAYS, default=DEFAULT_RETENTION_DAYS): selector.NumberSelector(
+                    selector.NumberSelectorConfig(
+                        min=0, max=365, step=1,
+                        mode=selector.NumberSelectorMode.SLIDER,
+                        unit_of_measurement="дн",
+                    )
+                ),
+                vol.Optional(CONF_CONTROLLED_ENTITIES, default=[]): selector.EntitySelector(
+                    selector.EntitySelectorConfig(
+                        domain=["light", "switch"],
+                        multiple=True,
+                    )
+                ),
+                vol.Optional(CONF_CONTROL_STATES, default=DEFAULT_CONTROL_STATES): selector.SelectSelector(
+                    selector.SelectSelectorConfig(
+                        options=CONTROL_STATE_OPTIONS,
+                        multiple=True,
+                        mode=selector.SelectSelectorMode.LIST,
+                    )
+                ),
                 vol.Required(CONF_LOG_LEVEL, default=DEFAULT_LOG_LEVEL): selector.SelectSelector(
                     selector.SelectSelectorConfig(
                         options=[
@@ -216,6 +247,31 @@ class MotionRecorderOptionsFlow(config_entries.OptionsFlow):
                         unit_of_measurement="дн",
                     )
                 ),
+                vol.Optional(
+                    CONF_CONTROLLED_ENTITIES,
+                    default=self.config_entry.options.get(
+                        CONF_CONTROLLED_ENTITIES,
+                        self.config_entry.data.get(CONF_CONTROLLED_ENTITIES, [])
+                    )
+                ): selector.EntitySelector(
+                    selector.EntitySelectorConfig(
+                        domain=["light", "switch"],
+                        multiple=True,
+                    )
+                ),
+                vol.Optional(
+                    CONF_CONTROL_STATES,
+                    default=self.config_entry.options.get(
+                        CONF_CONTROL_STATES,
+                        self.config_entry.data.get(CONF_CONTROL_STATES, DEFAULT_CONTROL_STATES)
+                    )
+                ): selector.SelectSelector(
+                    selector.SelectSelectorConfig(
+                        options=CONTROL_STATE_OPTIONS,
+                        multiple=True,
+                        mode=selector.SelectSelectorMode.LIST,
+                    )
+                ),
                 vol.Required(
                     CONF_LOG_LEVEL,
                     default=self.config_entry.options.get(CONF_LOG_LEVEL,

custom_components/motion_recorder/const.py

@@ -14,6 +14,8 @@ CONF_FORCE_STOP_SENSOR = "force_stop_sensor"
 CONF_FORCE_STOP_STATE = "force_stop_state"
 CONF_LOG_LEVEL = "log_level"
 CONF_RETENTION_DAYS = "retention_days"
+CONF_CONTROLLED_ENTITIES = "controlled_entities"
+CONF_CONTROL_STATES = "control_states"
 
 # Defaults
 DEFAULT_NAME = "Motion Recorder"
@@ -26,6 +28,7 @@ DEFAULT_OFF_DELAY = 10
 DEFAULT_FORCE_STOP_STATE = "off"
 DEFAULT_LOG_LEVEL = "INFO"
 DEFAULT_RETENTION_DAYS = 7
+DEFAULT_CONTROL_STATES = ["recording"]
 
 # Sensor states
 STATE_IDLE = "idle"
@@ -33,6 +36,15 @@ STATE_DETECTING = "detecting"
 STATE_RECORDING = "recording"
 STATE_DELAYING = "delaying"
 STATE_FINALIZING = "finalizing"
-STATE_COMPLETED = "completed"
 STATE_ERROR = "error"
 STATE_DISABLED = "disabled"
+
+ALL_STATES = [
+    STATE_IDLE,
+    STATE_DETECTING,
+    STATE_RECORDING,
+    STATE_DELAYING,
+    STATE_FINALIZING,
+    STATE_ERROR,
+    STATE_DISABLED,
+]

custom_components/motion_recorder/coordinator.py

@@ -21,13 +21,15 @@ from .const import (
     CONF_FORCE_STOP_SENSOR,
     CONF_FORCE_STOP_STATE,
     CONF_RETENTION_DAYS,
+    CONF_CONTROLLED_ENTITIES,
+    CONF_CONTROL_STATES,
     DEFAULT_RETENTION_DAYS,
+    DEFAULT_CONTROL_STATES,
     STATE_IDLE,
     STATE_DETECTING,
     STATE_RECORDING,
     STATE_DELAYING,
     STATE_FINALIZING,
-    STATE_COMPLETED,
     STATE_ERROR,
     STATE_DISABLED,
 )
@@ -39,7 +41,6 @@ except ImportError:
 
 _MIN_RECORDING_SIZE = 1024
 
-# Глобальный логгер для всего модуля
 _LOGGER = logging.getLogger(__name__)
 
 
@@ -79,6 +80,11 @@ class MotionRecorderCoordinator(DataUpdateCoordinator):
         self.force_stop_state = _get_config_value(entry, CONF_FORCE_STOP_STATE, "off")
         self.retention_days = _get_config_value(entry, CONF_RETENTION_DAYS, DEFAULT_RETENTION_DAYS)
 
+        # Управляемые устройства
+        self.controlled_entities = _get_config_value(entry, CONF_CONTROLLED_ENTITIES, [])
+        self.control_states = _get_config_value(entry, CONF_CONTROL_STATES, DEFAULT_CONTROL_STATES)
+        self._we_turned_on: set[str] = set()
+
         # State management
         self._state = STATE_IDLE
         self._attributes = {}
@@ -86,6 +92,8 @@ class MotionRecorderCoordinator(DataUpdateCoordinator):
         # Enabled state
         self._enabled = True
         
+        self._force_stopped = False
+
         # Listeners
         self._unsub_motion_listeners = []
         self._unsub_force_stop_listener = None
@@ -140,6 +148,7 @@ class MotionRecorderCoordinator(DataUpdateCoordinator):
         attrs["recordings_count"] = self._recordings_count
         attrs["total_duration"] = self._total_duration
         attrs["total_size"] = self._total_size
+        attrs["force_stopped"] = self._force_stopped
         return attrs
 
     @property
@@ -153,21 +162,47 @@ class MotionRecorderCoordinator(DataUpdateCoordinator):
         _LOGGER.info("Recording %s", "enabled" if enabled else "disabled")
 
         if not enabled:
-            # Останавливаем текущую запись, если она идёт
+            await self._cancel_all_timers()
+            
+            # Останавливаем запись если идёт
             if self._state == STATE_RECORDING:
                 await self._stop_recording()
-            # Переходим в состояние "disabled"
+            
+            # Переходим в disabled
             await self._update_state(STATE_DISABLED)
         else:
-            # Возвращаемся в idle (только если сейчас disabled)
+            # Включаем только если не заблокированы force_stop
-            if self._state == STATE_DISABLED:
+            if self._force_stopped:
+                _LOGGER.info("Cannot enable: force stop is active")
+                await self._update_state(STATE_DISABLED)
+            else:
                 await self._update_state(STATE_IDLE)
 
+        self.async_set_updated_data({
+            "state": self._state,
+            "attributes": self.attributes
+        })
+
+    async def _cancel_all_timers(self) -> None:
+        """Отменить все активные таймеры."""
+        if self._motion_detect_timer:
+            _LOGGER.debug("Cancelling motion detect timer")
+            self._motion_detect_timer()
+            self._motion_detect_timer = None
+        
+        if self._off_delay_timer:
+            _LOGGER.debug("Cancelling off-delay timer")
+            self._off_delay_timer()
+            self._off_delay_timer = None
+
     async def async_setup(self):
         """Set up the coordinator."""
         _LOGGER.info("Setting up Motion Recorder coordinator for %s", self.camera_entity)
-        _LOGGER.info("Settings: max_duration=%s, off_delay=%s, retention_days=%s", 
+        _LOGGER.info(
-                    self.max_duration, self.off_delay, self.retention_days)
+            "Settings: max_duration=%s, off_delay=%s, retention_days=%s, controlled_entities=%s, control_states=%s",
+            self.max_duration, self.off_delay, self.retention_days,
+            self.controlled_entities, self.control_states
+        )
         await self._update_state(STATE_IDLE)
         await self._start_listening()
 
@@ -190,6 +225,18 @@ class MotionRecorderCoordinator(DataUpdateCoordinator):
             self._cleanup_unsub()
             self._cleanup_unsub = None
 
+        # Выключаем все устройства, которые мы включили
+        for entity_id in list(self._we_turned_on):
+            try:
+                domain = entity_id.split(".")[0]
+                _LOGGER.info("Shutdown: turning off %s", entity_id)
+                await self.hass.services.async_call(
+                    domain, "turn_off", {"entity_id": entity_id}, blocking=False,
+                )
+            except Exception as err:
+                _LOGGER.error("Error turning off %s on shutdown: %s", entity_id, err)
+        self._we_turned_on.clear()
+
         if self._current_stream:
             await self._stop_recording()
 
@@ -204,6 +251,85 @@ class MotionRecorderCoordinator(DataUpdateCoordinator):
             "attributes": self.attributes
         })
 
+        # Управляем устройствами при изменении состояния
+        if old_state != state:
+            await self._update_controlled_entities()
+
+    async def _update_controlled_entities(self) -> None:
+        """Включить/выключить управляемые устройства в зависимости от состояния."""
+        if not self.controlled_entities:
+            return
+
+        should_be_on = self._state in self.control_states
+
+        for entity_id in self.controlled_entities:
+            try:
+                domain = entity_id.split(".")[0]
+                current_state = self.hass.states.get(entity_id)
+
+                if current_state is None:
+                    _LOGGER.warning("Controlled entity %s not found, skipping", entity_id)
+                    continue
+
+                is_on = current_state.state == "on"
+
+                if should_be_on and not is_on:
+                    _LOGGER.info("Turning ON %s because state is '%s'", entity_id, self._state)
+                    await self.hass.services.async_call(
+                        domain, "turn_on", {"entity_id": entity_id}, blocking=False,
+                    )
+                    self._we_turned_on.add(entity_id)
+
+                elif not should_be_on and is_on and entity_id in self._we_turned_on:
+                    _LOGGER.info("Turning OFF %s because state is '%s'", entity_id, self._state)
+                    await self.hass.services.async_call(
+                        domain, "turn_off", {"entity_id": entity_id}, blocking=False,
+                    )
+                    self._we_turned_on.discard(entity_id)
+
+            except Exception as err:
+                _LOGGER.error("Error controlling entity %s: %s", entity_id, err, exc_info=True)
+
+    async def _cleanup_old_recordings(self, now=None):
+        """Удалить записи старше retention_days."""
+        if self.retention_days == 0:
+            _LOGGER.debug("Retention days is 0, skipping cleanup")
+            return
+
+        save_dir = self._get_save_dir()
+        if not save_dir.exists():
+            _LOGGER.debug("Save directory does not exist: %s", save_dir)
+            return
+
+        _LOGGER.info("Starting cleanup of recordings older than %d days", self.retention_days)
+
+        cutoff_time = datetime.now() - timedelta(days=self.retention_days)
+        deleted_count = 0
+        deleted_size = 0
+
+        def _cleanup():
+            nonlocal deleted_count, deleted_size
+            try:
+                for file_path in save_dir.glob("*.mp4"):
+                    if file_path.stat().st_mtime < cutoff_time.timestamp():
+                        size = file_path.stat().st_size
+                        file_path.unlink()
+                        deleted_count += 1
+                        deleted_size += size
+                        _LOGGER.debug("Deleted old recording: %s", file_path.name)
+            except Exception as err:
+                _LOGGER.error("Error during cleanup: %s", err)
+
+        await self.hass.async_add_executor_job(_cleanup)
+
+        if deleted_count > 0:
+            _LOGGER.info(
+                "Cleanup completed: deleted %d files (%.1f MB)",
+                deleted_count, deleted_size / (1024 * 1024)
+            )
+        else:
+            _LOGGER.debug("No old recordings found to delete")
+
     async def _start_listening(self):
         """Start listening to motion sensors."""
         _LOGGER.info("Starting to listen to motion sensors: %s", self.motion_sensors)
@@ -242,19 +368,16 @@ class MotionRecorderCoordinator(DataUpdateCoordinator):
         old_s = old_state.state if old_state else None
         new_s = new_state.state
 
-        # ИГНОРИРУЕМ события во время финализации
+        if self._state == STATE_FINALIZING:
-        if self._state in (STATE_FINALIZING, STATE_COMPLETED):
             _LOGGER.debug("Ignoring motion event during %s", self._state)
             return
 
         _LOGGER.debug("Motion event: %s %s → %s", sensor_entity, old_s, new_s)
 
-        # ФРОНТ ВВЕРХ
         if new_s == "on" and old_s != "on":
             _LOGGER.debug("Motion FRONT UP: %s (%s → %s)", sensor_entity, old_s, new_s)
             self.hass.async_create_task(self._handle_motion_detected(sensor_entity))
 
-        # ФРОНТ ВНИЗ
         elif old_s == "on" and new_s != "on":
             _LOGGER.debug("Motion FRONT DOWN: %s (%s → %s)", sensor_entity, old_s, new_s)
             self.hass.async_create_task(self._handle_motion_stopped())
@@ -266,9 +389,43 @@ class MotionRecorderCoordinator(DataUpdateCoordinator):
         if not new_state:
             return
 
-        if new_state.state == self.force_stop_state:
+        new_s = new_state.state
-            _LOGGER.info("Force stop triggered by %s", event.data.get("entity_id"))
+        sensor_entity = event.data.get("entity_id")
-            self.hass.async_create_task(self._force_stop_recording())
+        
+        _LOGGER.debug("Force stop sensor %s changed to: %s", sensor_entity, new_s)
+
+        if new_s == self.force_stop_state:
+            _LOGGER.info("Force stop ACTIVATED by %s", sensor_entity)
+            self.hass.async_create_task(self._activate_force_stop())
+        else:
+            _LOGGER.info("Force stop DEACTIVATED by %s", sensor_entity)
+            self.hass.async_create_task(self._deactivate_force_stop())
+
+    async def _activate_force_stop(self) -> None:
+        """Активировать force stop блокировку."""
+        self._force_stopped = True
+        _LOGGER.info("Force stop blocking activated")
+        
+        # Отменяем все таймеры
+        await self._cancel_all_timers()
+        
+        # Останавливаем запись если идёт
+        if self._state == STATE_RECORDING:
+            await self._stop_recording()
+        
+        # Переходим в disabled
+        await self._update_state(STATE_DISABLED)
+
+    async def _deactivate_force_stop(self) -> None:
+        """Деактивировать force stop блокировку."""
+        self._force_stopped = False
+        _LOGGER.info("Force stop blocking deactivated")
+        
+        # Возвращаемся в idle только если запись включена
+        if self._enabled:
+            await self._update_state(STATE_IDLE)
+        else:
+            await self._update_state(STATE_DISABLED)
 
     def _is_any_motion_active(self) -> bool:
         """Check if any motion sensor is currently in 'on' state."""
@@ -284,6 +441,10 @@ class MotionRecorderCoordinator(DataUpdateCoordinator):
             _LOGGER.debug("Recording disabled, ignoring motion")
             return
         
+        if self._force_stopped:
+            _LOGGER.debug("Force stop active, ignoring motion")
+            return
+
         _LOGGER.debug("Motion detected by %s, current state: %s", triggered_by, self._state)
 
         if self._state == STATE_RECORDING:
@@ -315,9 +476,7 @@ class MotionRecorderCoordinator(DataUpdateCoordinator):
             _LOGGER.debug("Starting motion filter timer for %d seconds", self.motion_filter)
             try:
                 self._motion_detect_timer = async_call_later(
-                    self.hass,
+                    self.hass, self.motion_filter, self._start_recording_after_filter
-                    self.motion_filter,
-                    self._start_recording_after_filter
                 )
             except Exception as err:
                 _LOGGER.error("Failed to create motion filter timer: %s", err)
@@ -327,6 +486,12 @@ class MotionRecorderCoordinator(DataUpdateCoordinator):
 
     async def _start_recording_after_filter(self, _=None):
         """Start recording after motion filter."""
+        if not self._enabled or self._force_stopped:
+            _LOGGER.debug("Cannot start recording: enabled=%s, force_stopped=%s", 
+                         self._enabled, self._force_stopped)
+            await self._update_state(STATE_IDLE if self._enabled else STATE_DISABLED)
+            return
+        
         _LOGGER.debug("Starting recording after filter")
         self._motion_detect_timer = None
         triggered_by = self._attributes.get("triggered_by")
@@ -334,6 +499,10 @@ class MotionRecorderCoordinator(DataUpdateCoordinator):
 
     async def _handle_motion_stopped(self):
         """Handle motion stopped with off-delay."""
+        if self._force_stopped:
+            _LOGGER.debug("Force stop active, ignoring motion stopped")
+            return
+        
         _LOGGER.debug("Motion stopped, current state: %s", self._state)
 
         if self._is_any_motion_active():
@@ -355,9 +524,7 @@ class MotionRecorderCoordinator(DataUpdateCoordinator):
                 _LOGGER.debug("Starting off-delay timer for %d seconds", self.off_delay)
                 try:
                     self._off_delay_timer = async_call_later(
-                        self.hass,
+                        self.hass, self.off_delay, self._stop_recording_after_delay
-                        self.off_delay,
-                        self._stop_recording_after_delay
                     )
                 except Exception as err:
                     _LOGGER.error("Failed to create off-delay timer: %s", err)
@@ -371,10 +538,19 @@ class MotionRecorderCoordinator(DataUpdateCoordinator):
                 _LOGGER.debug("Cancelling motion filter timer")
                 self._motion_detect_timer()
                 self._motion_detect_timer = None
-            await self._update_state(STATE_IDLE)
+            
+            if not self._enabled:
+                await self._update_state(STATE_DISABLED)
+            else:
+                await self._update_state(STATE_IDLE)
 
     async def _stop_recording_after_delay(self, _=None):
         """Stop recording after off-delay."""
+        if self._force_stopped or not self._enabled:
+            _LOGGER.debug("Cannot stop recording: enabled=%s, force_stopped=%s", 
+                         self._enabled, self._force_stopped)
+            return
+        
         _LOGGER.debug("Off-delay timer expired")
         self._off_delay_timer = None
 
@@ -388,8 +564,13 @@ class MotionRecorderCoordinator(DataUpdateCoordinator):
 
     async def _start_recording(self, triggered_by):
         """Start recording the camera."""
+        if not self._enabled or self._force_stopped:
+            _LOGGER.warning("Cannot start recording: enabled=%s, force_stopped=%s", 
+                          self._enabled, self._force_stopped)
+            await self._update_state(STATE_IDLE if self._enabled else STATE_DISABLED)
+            return
+        
         try:
-            # Проверяем, есть ли уже активная запись
             if self._current_stream:
                 recorder_output = self._current_stream.outputs().get(_RECORDER_PROVIDER)
                 if recorder_output is not None:
@@ -425,13 +606,11 @@ class MotionRecorderCoordinator(DataUpdateCoordinator):
             filename = save_dir / f"{timestamp}.mp4"
             self._current_filename = str(filename)
 
-            # INFO: Начало записии
             _LOGGER.info(
                 "Recording started: %s (duration=%ds, lookback=%ds)",
                 filename, self.max_duration, self.prebuffer
             )
 
-            # Запускаем запись
             self._current_record_task = asyncio.create_task(
                 stream.async_record(
                     video_path=str(filename),
@@ -440,16 +619,17 @@ class MotionRecorderCoordinator(DataUpdateCoordinator):
                 )
             )
 
-            # Ждём завершения
             await self._current_record_task
-            
             await self._finalize_recording(str(filename))
 
         except Exception as err:
             _LOGGER.error("Error starting recording: %s", err, exc_info=True)
             await self._update_state(STATE_ERROR, error_message=str(err))
             await asyncio.sleep(5)
-            await self._update_state(STATE_IDLE)
+            if not self._enabled:
+                await self._update_state(STATE_DISABLED)
+            else:
+                await self._update_state(STATE_IDLE)
 
     async def _stop_recording(self):
         """Stop current recording."""
@@ -465,7 +645,6 @@ class MotionRecorderCoordinator(DataUpdateCoordinator):
                 _LOGGER.debug("Removing recorder provider to stop recording")
                 await self._current_stream.remove_provider(recorder_output)
 
-                # Ждём завершения задачи записии
                 if self._current_record_task and not self._current_record_task.done():
                     _LOGGER.debug("Waiting for record task to complete after stop signal")
                     try:
@@ -487,13 +666,13 @@ class MotionRecorderCoordinator(DataUpdateCoordinator):
             _LOGGER.error("Error stopping recording: %s", err, exc_info=True)
             await self._update_state(STATE_ERROR, error_message=str(err))
             await asyncio.sleep(5)
-            if not self._enabled:
+            if not self._enabled or self._force_stopped:
                 await self._update_state(STATE_DISABLED)
             else:
                 await self._update_state(STATE_IDLE)
 
     async def _force_stop_recording(self):
-        """Force stop recording."""
+        """Force stop recording (вызывается при активации force_stop)."""
         _LOGGER.info("Force stop recording called")
         await self._stop_recording()
 
@@ -501,12 +680,10 @@ class MotionRecorderCoordinator(DataUpdateCoordinator):
         """Finalize recording and check file."""
         _LOGGER.debug("Finalizing recording: %s", filename)
 
-        # Переходим в finalizing
         await self._update_state(STATE_FINALIZING, last_file_path=filename)
 
         filepath = Path(filename)
 
-        # Ждём файл максимум 2 секунды с шагом 0.2с
         for _ in range(10):
             await asyncio.sleep(0.2)
             if filepath.is_file():
@@ -526,7 +703,6 @@ class MotionRecorderCoordinator(DataUpdateCoordinator):
             self._total_duration += int(duration)
             self._total_size += size
 
-            # INFO: Конец записии
             _LOGGER.info(
                 "Recording completed: %s (%.1f sec, %d bytes). Total: %d recordings, %d sec, %d bytes",
                 filepath, duration, size,
@@ -535,100 +711,14 @@ class MotionRecorderCoordinator(DataUpdateCoordinator):
         else:
             _LOGGER.warning("Recording file not found or too small: %s", filename)
 
-        # Очищаем ресурсы
         self._current_stream = None
         self._current_record_task = None
         self._recording_start_time = None
         self._current_filename = None
 
-    async def _finalize_recording(self, filename):
+        if not self._enabled or self._force_stopped:
-        """Finalize recording and check file."""
+            _LOGGER.debug("Recording disabled or force stopped during finalization, transitioning to disabled")
-        _LOGGER.debug("Finalizing recording: %s", filename)
-        
-        # Переходим в finalizing
-        await self._update_state(STATE_FINALIZING, last_file_path=filename)
-        
-        filepath = Path(filename)
-        
-        # Ждём файл максимум 2 секунды с шагом 0.2с
-        for _ in range(10):
-            await asyncio.sleep(0.2)
-            if filepath.is_file():
-                size = filepath.stat().st_size
-                if size > _MIN_RECORDING_SIZE:
-                    break
-        
-        if filepath.is_file() and filepath.stat().st_size > _MIN_RECORDING_SIZE:
-            size = filepath.stat().st_size
-            
-            if self._recording_start_time:
-                duration = (dt_util.utcnow() - self._recording_start_time).total_seconds()
-            else:
-                duration = self.max_duration
-            
-            self._recordings_count += 1
-            self._total_duration += int(duration)
-            self._total_size += size
-            
-            # INFO: Конец записии
-            _LOGGER.info(
-                "Recording completed: %s (%.1f sec, %d bytes). Total: %d recordings, %d sec, %d bytes",
-                filepath, duration, size,
-                self._recordings_count, self._total_duration, self._total_size
-            )
-        else:
-            _LOGGER.warning("Recording file not found or too small: %s", filename)
-        
-        # Очищаем ресурсы
-        self._current_stream = None
-        self._current_record_task = None
-        self._recording_start_time = None
-        self._current_filename = None
-        
-        if not self._enabled:
-            _LOGGER.debug("Recording disabled during finalization, transitioning to disabled")
             await self._update_state(STATE_DISABLED)
         else:
             _LOGGER.debug("Transitioning to idle")
             await self._update_state(STATE_IDLE)
-
-    async def _cleanup_old_recordings(self, now=None):
-        """Удалить записи старше retention_days."""
-        if self.retention_days == 0:
-            _LOGGER.debug("Retention days is 0, skipping cleanup")
-            return
-        
-        save_dir = self._get_save_dir()
-        if not save_dir.exists():
-            _LOGGER.debug("Save directory does not exist: %s", save_dir)
-            return
-        
-        _LOGGER.info("Starting cleanup of recordings older than %d days", self.retention_days)
-        
-        cutoff_time = datetime.now() - timedelta(days=self.retention_days)
-        deleted_count = 0
-        deleted_size = 0
-        
-        def _cleanup():
-            nonlocal deleted_count, deleted_size
-            try:
-                for file_path in save_dir.glob("*.mp4"):
-                    if file_path.stat().st_mtime < cutoff_time.timestamp():
-                        size = file_path.stat().st_size
-                        file_path.unlink()
-                        deleted_count += 1
-                        deleted_size += size
-                        _LOGGER.debug("Deleted old recording: %s", file_path.name)
-            except Exception as err:
-                _LOGGER.error("Error during cleanup: %s", err)
-        
-        await self.hass.async_add_executor_job(_cleanup)
-        
-        if deleted_count > 0:
-            _LOGGER.info(
-                "Cleanup completed: deleted %d files (%.1f MB)",
-                deleted_count,
-                deleted_size / (1024 * 1024)
-            )
-        else:
-            _LOGGER.debug("No old recordings found to delete")

custom_components/motion_recorder/manifest.json

@@ -1,12 +1,12 @@
 {
   "domain": "motion_recorder",
   "name": "Motion Recorder",
-  "version": "1.0.0",
-  "documentation": "https://github.com/sirmrak/motion_recorder",
-  "issue_tracker": "https://github.com/sirmrak/motion_recorder/issues",
-  "dependencies": ["camera", "stream"],
   "codeowners": ["@sirmrak"],
-  "requirements": [],
+  "config_flow": true,
+  "dependencies": ["camera", "stream"],  
+  "documentation": "https://github.com/sirmrak/motion_recorder",
   "iot_class": "local_push",
-  "config_flow": true
+  "issue_tracker": "https://github.com/sirmrak/motion_recorder/issues",
+  "requirements": [],
+  "version": "1.1.2"
 }

custom_components/motion_recorder/sensor.py

@@ -6,7 +6,7 @@ from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 from homeassistant.helpers.device_registry import DeviceInfo
 
-from .const import DOMAIN, CONF_CAMERA_ENTITY
+from .const import DOMAIN
 
 
 async def async_setup_entry(
@@ -30,7 +30,6 @@ class MotionRecorderStatusSensor(CoordinatorEntity, SensorEntity):
         self._attr_name = f"{entry.title} Статус"
         self._attr_translation_key = "motion_recorder_status"
 
-        # Добавляем информацию об устройстве
         self._attr_device_info = DeviceInfo(
             identifiers={(DOMAIN, entry.entry_id)},
             name=entry.title,
@@ -38,14 +37,12 @@ class MotionRecorderStatusSensor(CoordinatorEntity, SensorEntity):
             model="Camera Recording Integration",
         )
 
-        # Icon mapping
         self._icon_map = {
             "idle": "mdi:sleep",
             "detecting": "mdi:motion-sensor",
             "recording": "mdi:record-rec",
             "delaying": "mdi:timer-sand",
             "finalizing": "mdi:file-check",
-            "completed": "mdi:check-circle",
             "error": "mdi:alert-circle",
             "disabled": "mdi:video-off",
         }

custom_components/motion_recorder/strings.json

@@ -14,9 +14,11 @@
           "motion_sensors": "Датчики движения",
           "motion_filter": "Фильтр обнаружения движения (сек, 0 = без фильтрации)",
           "off_delay": "Задержка после пропадания движения (сек, 0 = без задержки)",
-          "retention_days": "Хранить записи (дней, 0 = не удалять)",
           "force_stop_sensor": "Датчик принудительной остановки (binary_sensor, switch, input_boolean)",
           "force_stop_state": "Состояние для остановки",
+          "retention_days": "Хранить записи (дней, 0 = не удалять)",
+          "controlled_entities": "Управляемые устройства (light/switch)",
+          "control_states": "Включать при состояниях",
           "log_level": "Уровень логирования"
         },
         "data_description": {
@@ -24,14 +26,16 @@
           "camera_entity": "Выберите камеру из списка доступных",
           "save_path": "Папка для сохранения записей относительно /media. Поддерживаются переменные, например camera_name",
           "filename_template": "Выберите формат даты и времени для имён файлов записей. Все форматы содержат секунды, чтобы избежать перезаписи файлов при нескольких срабатываниях в одну минуту",
-          "max_duration": "Максимальное время одной записии (10-3600 секунд). Если движение не прекратится, запись остановится по таймауту",
+          "max_duration": "Максимальное время одной записи (10-3600 секунд). Если движение не прекратится, запись остановится по таймауту",
           "prebuffer": "Сколько секунд до обнаружения движения включить в запись. Работает только если стрим уже активен",
           "motion_sensors": "Можно выбрать несколько датчиков. Запись начнётся при сработке любого из них",
           "motion_filter": "Задержка перед началом записи. Если движение пропадёт раньше — запись не начнётся (защита от ложных срабатываний)",
           "off_delay": "Сколько секунд ждать после пропадания движения перед остановкой записи. Если движение вернётся — таймер сбросится",
-          "retention_days": "Автоматически удалять записи старше указанного количества дней. 0 = не удалять никогда. Очистка выполняется ежедневно в 3:00",
           "force_stop_sensor": "Необязательно. Сущность, при переходе в указанное состояние запись немедленно остановится",
           "force_stop_state": "Значение состояния датчика принудительной остановки (обычно 'off' или 'on')",
+          "retention_days": "Автоматически удалять записи старше указанного количества дней. 0 = не удалять никогда. Очистка выполняется ежедневно в 3:00",
+          "controlled_entities": "Список светильников или переключателей, которые будут автоматически включаться/выключаться в зависимости от состояния интеграции",
+          "control_states": "Отметьте состояния, при которых управляемые устройства должны быть включены. В остальных состояниях они будут выключены (только если были включены интеграцией)",
           "log_level": "Уровень детализации логов. DEBUG — для отладки, INFO — обычный режим"
         }
       }
@@ -52,15 +56,19 @@
           "motion_filter": "Фильтр обнаружения движения (сек, 0 = без фильтрации)",
           "off_delay": "Задержка после пропадания движения (сек, 0 = без задержки)",
           "retention_days": "Хранить записи (дней, 0 = не удалять)",
+          "controlled_entities": "Управляемые устройства (light/switch)",
+          "control_states": "Включать при состояниях",
           "log_level": "Уровень логирования"
         },
         "data_description": {
           "filename_template": "Выберите формат даты и времени для имён файлов записей",
-          "max_duration": "Максимальное время одной записии (10-3600 секунд)",
+          "max_duration": "Максимальное время одной записи (10-3600 секунд)",
           "prebuffer": "Сколько секунд до обнаружения движения включить в запись",
           "motion_filter": "Задержка перед началом записи для защиты от ложных срабатываний",
           "off_delay": "Сколько секунд ждать после пропадания движения перед остановкой записи",
           "retention_days": "Автоматически удалять записи старше указанного количества дней. 0 = не удалять никогда",
+          "controlled_entities": "Список светильников или переключателей для автоматического управления",
+          "control_states": "Состояния, при которых устройства должны быть включены",
           "log_level": "Уровень детализации логов"
         }
       }

custom_components/motion_recorder/translations/en.json

@@ -14,9 +14,11 @@
           "motion_sensors": "Motion sensors",
           "motion_filter": "Motion detection filter (seconds, 0 = no filter)",
           "off_delay": "Delay after motion stops (seconds, 0 = no delay)",
-          "retention_days": "Keep recordings (days, 0 = never delete)",
           "force_stop_sensor": "Force stop sensor (binary_sensor, switch, input_boolean)",
           "force_stop_state": "Stop state value",
+          "retention_days": "Keep recordings (days, 0 = never delete)",
+          "controlled_entities": "Controlled devices (light/switch)",
+          "control_states": "Turn on at states",
           "log_level": "Log level"
         },
         "data_description": {
@@ -29,9 +31,11 @@
           "motion_sensors": "You can select multiple sensors. Recording will start when any of them triggers",
           "motion_filter": "Delay before starting recording. If motion stops earlier — recording will not start (false trigger protection)",
           "off_delay": "How many seconds to wait after motion stops before stopping recording. If motion returns — timer resets",
-          "retention_days": "Automatically delete recordings older than specified days. 0 = never delete. Cleanup runs daily at 03:00",
           "force_stop_sensor": "Optional. Entity that will immediately stop recording when it reaches the specified state",
           "force_stop_state": "State value of the force stop sensor (usually 'off' or 'on')",
+          "retention_days": "Automatically delete recordings older than specified days. 0 = never delete. Cleanup runs daily at 03:00",
+          "controlled_entities": "List of lights or switches that will be automatically turned on/off depending on the integration state",
+          "control_states": "Select states when controlled devices should be turned on. In other states they will be turned off (only if they were turned on by the integration)",
           "log_level": "Log detail level. DEBUG — for debugging, INFO — normal mode"
         }
       }
@@ -52,6 +56,8 @@
           "motion_filter": "Motion detection filter (seconds, 0 = no filter)",
           "off_delay": "Delay after motion stops (seconds, 0 = no delay)",
           "retention_days": "Keep recordings (days, 0 = never delete)",
+          "controlled_entities": "Controlled devices (light/switch)",
+          "control_states": "Turn on at states",
           "log_level": "Log level"
         },
         "data_description": {
@@ -61,6 +67,8 @@
           "motion_filter": "Delay before starting recording for false trigger protection",
           "off_delay": "How many seconds to wait after motion stops before stopping recording",
           "retention_days": "Automatically delete recordings older than specified days. 0 = never delete",
+          "controlled_entities": "List of lights or switches for automatic control",
+          "control_states": "States when devices should be turned on",
           "log_level": "Log detail level"
         }
       }
@@ -76,7 +84,6 @@
           "recording": "Recording",
           "delaying": "Delaying",
           "finalizing": "Finalizing",
-          "completed": "Completed",
           "error": "Error",
           "disabled": "Disabled"
         }

custom_components/motion_recorder/translations/ru.json

@@ -14,9 +14,11 @@
           "motion_sensors": "Датчики движения",
           "motion_filter": "Фильтр обнаружения движения (сек, 0 = без фильтрации)",
           "off_delay": "Задержка после пропадания движения (сек, 0 = без задержки)",
-          "retention_days": "Хранить записи (дней, 0 = не удалять)",
           "force_stop_sensor": "Датчик принудительной остановки (binary_sensor, switch, input_boolean)",
           "force_stop_state": "Состояние для остановки",
+          "retention_days": "Хранить записи (дней, 0 = не удалять)",
+          "controlled_entities": "Управляемые устройства (light/switch)",
+          "control_states": "Включать при состояниях",
           "log_level": "Уровень логирования"
         },
         "data_description": {
@@ -24,14 +26,16 @@
           "camera_entity": "Выберите камеру из списка доступных",
           "save_path": "Папка для сохранения записей относительно /media. Поддерживаются переменные, например camera_name",
           "filename_template": "Выберите формат даты и времени для имён файлов записей. Все форматы содержат секунды, чтобы избежать перезаписи файлов при нескольких срабатываниях в одну минуту",
-          "max_duration": "Максимальное время одной записии (10-3600 секунд). Если движение не прекратится, запись остановится по таймауту",
+          "max_duration": "Максимальное время одной записи (10-3600 секунд). Если движение не прекратится, запись остановится по таймауту",
           "prebuffer": "Сколько секунд до обнаружения движения включить в запись. Работает только если стрим уже активен",
           "motion_sensors": "Можно выбрать несколько датчиков. Запись начнётся при сработке любого из них",
           "motion_filter": "Задержка перед началом записи. Если движение пропадёт раньше — запись не начнётся (защита от ложных срабатываний)",
           "off_delay": "Сколько секунд ждать после пропадания движения перед остановкой записи. Если движение вернётся — таймер сбросится",
-          "retention_days": "Автоматически удалять записии старше указанного количества дней. 0 = не удалять никогда. Очистка выполняется ежедневно в 3:00",
           "force_stop_sensor": "Необязательно. Сущность, при переходе в указанное состояние запись немедленно остановится",
           "force_stop_state": "Значение состояния датчика принудительной остановки (обычно 'off' или 'on')",
+          "retention_days": "Автоматически удалять записи старше указанного количества дней. 0 = не удалять никогда. Очистка выполняется ежедневно в 3:00",
+          "controlled_entities": "Список светильников или переключателей, которые будут автоматически включаться/выключаться в зависимости от состояния интеграции",
+          "control_states": "Отметьте состояния, при которых управляемые устройства должны быть включены. В остальных состояниях они будут выключены (только если были включены интеграцией)",
           "log_level": "Уровень детализации логов. DEBUG — для отладки, INFO — обычный режим"
         }
       }
@@ -51,16 +55,20 @@
           "prebuffer": "Предбуфер (сек, 0 = отключено)",
           "motion_filter": "Фильтр обнаружения движения (сек, 0 = без фильтрации)",
           "off_delay": "Задержка после пропадания движения (сек, 0 = без задержки)",
-          "retention_days": "Хранить записии (дней, 0 = не удалять)",
+          "retention_days": "Хранить записи (дней, 0 = не удалять)",
+          "controlled_entities": "Управляемые устройства (light/switch)",
+          "control_states": "Включать при состояниях",
           "log_level": "Уровень логирования"
         },
         "data_description": {
           "filename_template": "Выберите формат даты и времени для имён файлов записей",
-          "max_duration": "Максимальное время одной записии (10-3600 секунд)",
+          "max_duration": "Максимальное время одной записи (10-3600 секунд)",
           "prebuffer": "Сколько секунд до обнаружения движения включить в запись",
-          "motion_filter": "Задержка перед началом записии для защиты от ложных срабатываний",
+          "motion_filter": "Задержка перед началом записи для защиты от ложных срабатываний",
-          "off_delay": "Сколько секунд ждать после пропадания движения перед остановкой записии",
+          "off_delay": "Сколько секунд ждать после пропадания движения перед остановкой записи",
-          "retention_days": "Автоматически удалять записии старше указанного количества дней. 0 = не удалять никогда",
+          "retention_days": "Автоматически удалять записи старше указанного количества дней. 0 = не удалять никогда",
+          "controlled_entities": "Список светильников или переключателей для автоматического управления",
+          "control_states": "Состояния, при которых устройства должны быть включены",
           "log_level": "Уровень детализации логов"
         }
       }
@@ -76,7 +84,6 @@
           "recording": "Запись",
           "delaying": "Задержка",
           "finalizing": "Завершение",
-          "completed": "Завершено",
           "error": "Ошибка",
           "disabled": "Отключено"
         }

pyproject.toml

@@ -0,0 +1,25 @@
+[tool.semantic_release]
+tag_format = "v{version}"
+
+version_variables = [
+    "custom_components/motion_recorder/manifest.json:version",
+]
+
+commit_message = "chore(release): v{version}"
+
+# ВАЖНО: не создаём релиз в Gitea (релиз будет в GitHub)
+upload_to_vcs_release = false
+
+[tool.semantic_release.remote]
+type = "gitea"
+domain = "192.168.200.208:3000"
+api_domain = "192.168.200.208:3000"
+
+[tool.semantic_release.branches.main]
+match = "(main|master)"
+prerelease = false
+
+[tool.semantic_release.commit_parser_options]
+allowed_tags = ["feat", "fix", "docs", "style", "refactor", "perf", "test", "chore", "revert"]
+minor_tags = ["feat"]
+patch_tags = ["fix", "perf"]