Home Assistant API接口：开发者集成指南
项目地址: https://gitcode.com/GitHub_Trending/co/core 1. 引言：解决智能家居集成的痛点
你是否曾面临这些挑战：智能家居设备品牌碎片化导致控制协议不统一？自行开发家庭自动化逻辑时缺乏标准化接口？第三方服务集成过程中认证与权限管理复杂？Home Assistant API（应用程序编程接口）为这些问题提供了统一解决方案。
读完本文你将获得：
- 掌握Home Assistant核心API架构与组件交互原理
- 学会使用事件总线（Event Bus）实现设备状态监听
- 掌握服务注册与调用的全流程开发
- 实现自定义集成的配置管理与生命周期控制
- 通过15+代码示例构建实用智能家居功能
2. Home Assistant API架构概览
Home Assistant采用模块化架构设计，核心API可分为四大功能域，通过分层设计实现高内聚低耦合：
2.1 核心组件关系
- HomeAssistant类：系统核心容器，管理所有组件生命周期与资源分配
- 事件总线(EventBus)：实现跨组件通信的松耦合机制
- 服务注册表(ServiceRegistry)：标准化功能调用接口
- 状态机(StateMachine)：统一管理设备状态与属性
2.2 API调用流程
3. 事件总线API详解
事件总线(Event Bus)是Home Assistant的神经系统，采用发布-订阅模式实现组件间通信。所有设备状态变化、系统事件和自定义通知都通过事件总线传递。
3.1 核心事件类型
| 事件类型 | 描述 | 数据结构 | 应用场景 |
|---|---|---|---|
state_changed | 实体状态变更 | {entity_id, old_state, new_state} | 设备状态监控、自动化触发 |
call_service | 服务调用事件 | {domain, service, service_data} | 操作审计、日志记录 |
homeassistant_start | 系统启动事件 | {} | 初始化任务调度 |
homeassistant_stop | 系统停止事件 | {} | 资源清理、状态保存 |
core_config_update | 配置更新事件 | {config} | 动态配置应用 |
3.2 事件监听实现
3.2.1 基本事件监听
async def async_setup(hass, config):
# 监听所有状态变更事件
def state_change_listener(event):
entity_id = event.data.get('entity_id')
old_state = event.data.get('old_state')
new_state = event.data.get('new_state')
_LOGGER.info(f"Entity {entity_id} changed from {old_state.state} to {new_state.state}")
hass.bus.async_listen('state_changed', state_change_listener)
return True
3.2.2 特定实体监听
async def async_setup(hass, config):
# 监听特定灯的状态变更
def light_state_changed(event):
new_state = event.data.get('new_state')
if new_state.state == 'on':
_LOGGER.info("客厅灯已开启")
# 触发其他自动化操作
# 使用通配符匹配实体ID
hass.bus.async_listen(
'state_changed',
light_state_changed,
event_filter=lambda e: e.data.get('entity_id') == 'light.living_room'
)
return True
3.2.3 一次性事件监听
async def async_setup(hass, config):
# 系统启动完成后执行初始化
async def on_startup(event):
_LOGGER.info("Home Assistant启动完成，执行初始化任务")
# 执行一次性初始化操作
await initialize_custom_components(hass)
hass.bus.async_listen_once('homeassistant_started', on_startup)
return True
3.3 事件发布实现
async def publish_custom_event(hass):
"""发布自定义事件示例"""
event_data = {
"device_id": "sensor.motion_123",
"motion_detected": True,
"timestamp": dt_util.utcnow().isoformat(),
"confidence": 0.92
}
# 发布自定义事件
hass.bus.async_fire(
event_type="motion_detected",
event_data=event_data,
origin="LOCAL" # 事件来源: LOCAL/REMOTE/AUTOMATION
)
4. 服务注册与调用API
服务(Service)是Home Assistant的功能调用接口，任何可执行操作（如开灯、调整温度）都封装为服务。服务采用domain.service命名规范，如light.turn_on。
4.1 服务注册流程
4.2 服务注册代码示例
4.2.1 基础服务注册
import voluptuous as vol
from homeassistant.core import ServiceCall
# 定义服务参数验证schema
SERVICE_SCHEMA = vol.Schema({
vol.Required('entity_id'): str,
vol.Optional('brightness', default=100): vol.All(vol.Coerce(int), vol.Range(min=1, max=255)),
vol.Optional('transition', default=1): vol.Coerce(int)
})
async def async_setup(hass, config):
# 实现服务回调
async def handle_custom_light_service(call: ServiceCall):
"""处理自定义灯光服务"""
entity_id = call.data['entity_id']
brightness = call.data['brightness']
transition = call.data['transition']
# 调用现有服务实现功能
await hass.services.async_call(
domain='light',
service='turn_on',
service_data={
'entity_id': entity_id,
'brightness': brightness,
'transition': transition
},
blocking=True # 等待服务执行完成
)
# 注册服务
hass.services.async_register(
domain='custom_light',
service='fade_in',
service_func=handle_custom_light_service,
schema=SERVICE_SCHEMA
)
return True
4.2.2 带权限控制的服务
from homeassistant.exceptions import Unauthorized
async def async_setup(hass, config):
async def secure_service_handler(call: ServiceCall):
"""带权限检查的服务示例"""
# 权限检查
if not has_permission(hass, call.context.user_id, "control_security"):
raise Unauthorized("用户无权限执行安全操作")
# 执行安全相关操作
_LOGGER.info(f"执行安全操作: {call.data}")
hass.services.async_register(
domain='security',
service='arm_system',
service_func=secure_service_handler,
schema=vol.Schema({
vol.Required('mode'): vol.In(['home', 'away', 'night'])
})
)
return True
4.3 服务调用示例
4.3.1 基础服务调用
# 在自动化或脚本中调用服务
async def trigger_security_alert(hass):
"""触发安全警报"""
try:
# 调用服务并等待结果
result = await hass.services.async_call(
domain='security',
service='arm_system',
service_data={'mode': 'away'},
blocking=True,
return_response=True
)
_LOGGER.info(f"安全系统布防结果: {result}")
except ServiceNotFound:
_LOGGER.error("安全服务未找到，请检查集成是否正确加载")
except ServiceValidationError as e:
_LOGGER.error(f"服务参数错误: {str(e)}")
4.3.2 批量设备控制
async def control_multiple_devices(hass):
"""同时控制多个设备"""
# 并行调用多个服务
tasks = [
hass.services.async_call('light', 'turn_on', {'entity_id': 'light.living_room'}),
hass.services.async_call('switch', 'turn_on', {'entity_id': 'switch.tv'}),
hass.services.async_call('climate', 'set_temperature', {
'entity_id': 'climate.thermostat',
'temperature': 22
})
]
# 等待所有任务完成
await asyncio.gather(*tasks)
_LOGGER.info("所有设备已按计划开启")
5. 状态管理API
状态机(StateMachine)负责跟踪所有实体的当前状态，提供状态读写、变更监听等核心功能。每个实体状态包含state字符串和attributes字典。
5.1 状态数据结构
# 状态对象结构示例
{
"entity_id": "light.kitchen",
"state": "on",
"attributes": {
"brightness": 200,
"color_temp": 3500,
"hs_color": [240, 100],
"rgb_color": [0, 0, 255],
"xy_color": [0.153, 0.054],
"friendly_name": "厨房灯",
"supported_features": 151,
"icon": "mdi:lightbulb"
},
"last_changed": "2023-11-15T08:30:45.123456+00:00",
"last_updated": "2023-11-15T08:30:45.123456+00:00",
"context": {
"id": "abc123def456",
"parent_id": null,
"user_id": "xyz789"
}
}
5.2 状态读写操作
5.2.1 获取实体状态
def get_device_status(hass, entity_id):
"""获取设备状态信息"""
# 获取单个实体状态
state = hass.states.get(entity_id)
if not state:
_LOGGER.warning(f"实体 {entity_id} 不存在")
return None
# 提取状态信息
status = {
"entity_id": state.entity_id,
"state": state.state,
"attributes": dict(state.attributes),
"last_changed": state.last_changed.isoformat(),
"last_updated": state.last_updated.isoformat()
}
return status
# 使用示例
kitchen_light = get_device_status(hass, "light.kitchen")
if kitchen_light and kitchen_light["state"] == "on":
_LOGGER.info(f"厨房灯当前亮度: {kitchen_light['attributes']['brightness']}")
5.2.2 设置实体状态
async def update_custom_sensor(hass):
"""更新自定义传感器状态"""
entity_id = "sensor.energy_usage"
# 准备状态数据
state = "125.5" # 主要状态值，通常为字符串
attributes = {
"unit_of_measurement": "kWh",
"friendly_name": "能源使用",
"icon": "mdi:flash",
"last_reset": dt_util.utc_from_timestamp(0).isoformat(),
"state_class": "measurement",
"device_class": "energy"
}
# 更新状态
await hass.states.async_set(
entity_id=entity_id,
new_state=state,
attributes=attributes,
force_update=True # 即使状态值相同也更新
)
_LOGGER.info(f"已更新 {entity_id} 状态为 {state} kWh")
5.2.3 状态变更监听
async def async_setup(hass, config):
"""监听温度变化并触发警报"""
async def temperature_alert_listener(entity_id, old_state, new_state):
"""温度变化监听器"""
if old_state is None: # 初始状态不触发
return
try:
current_temp = float(new_state.state)
if current_temp > 30:
# 温度过高，触发警报服务
await hass.services.async_call(
"alert", "fire",
{"entity_id": "alert.high_temperature", "message": f"温度过高: {current_temp}°C"}
)
except (ValueError, TypeError):
_LOGGER.warning(f"无法解析温度值: {new_state.state}")
# 监听温度传感器状态变化
hass.states.async_listen_entity_changes(
"sensor.temperature", # 实体ID，支持通配符如"sensor.temp_*"
temperature_alert_listener
)
return True
6. 配置管理API
配置管理API负责处理集成的配置流程，包括配置验证、存储、更新和迁移。Home Assistant支持YAML配置和UI配置两种方式，推荐使用配置条目(Config Entry)实现UI驱动的配置流程。
6.1 配置条目生命周期
6.2 配置条目实现示例
6.2.1 基础配置条目
from homeassistant.config_entries import ConfigEntry, SOURCE_IMPORT
from homeassistant.core import HomeAssistant
from homeassistant.helpers import config_validation as cv
# 配置schema定义
CONFIG_SCHEMA = cv.schema_with_slug_keys(
vol.Schema({
vol.Required('api_key'): cv.string,
vol.Required('device_id'): cv.string,
vol.Optional('update_interval', default=30): cv.positive_int
})
)
async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
"""设置配置条目"""
# 存储配置数据到hass.data
hass.data.setdefault(DOMAIN, {})[entry.entry_id] = {
'api_key': entry.data['api_key'],
'device_id': entry.data['device_id'],
'update_interval': entry.options.get('update_interval', 30)
}
# 初始化协调器
coordinator = CustomDataUpdateCoordinator(
hass,
config_entry=entry,
api_key=entry.data['api_key'],
device_id=entry.data['device_id']
)
# 存储协调器
hass.data[DOMAIN][entry.entry_id]['coordinator'] = coordinator
# 加载数据
await coordinator.async_config_entry_first_refresh()
# 注册实体
hass.async_create_task(
hass.config_entries.async_forward_entry_setup(entry, 'sensor')
)
return True
async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
"""卸载配置条目"""
# 取消实体注册
unload_ok = await hass.config_entries.async_forward_entry_unload(entry, 'sensor')
if unload_ok:
# 清理数据
hass.data[DOMAIN].pop(entry.entry_id)
if not hass.data[DOMAIN]:
del hass.data[DOMAIN]
return unload_ok
6.2.2 配置迁移与更新
async def async_migrate_entry(hass: HomeAssistant, config_entry: ConfigEntry) -> bool:
"""处理配置版本迁移"""
_LOGGER.info(f"迁移配置条目 {config_entry.entry_id} 从版本 {config_entry.version} 到 2")
# 版本1 -> 版本2迁移逻辑
if config_entry.version == 1:
new_data = {**config_entry.data}
# 移动location到options
if 'location' in new_data:
new_options = {**config_entry.options, 'location': new_data.pop('location')}
hass.config_entries.async_update_entry(
config_entry,
data=new_data,
options=new_options,
version=2
)
return True
async def async_setup(hass: HomeAssistant, config: dict) -> bool:
"""设置集成并处理YAML配置导入"""
if DOMAIN in config:
for entry_config in config[DOMAIN].values():
# 将YAML配置转换为配置条目
hass.async_create_task(
hass.config_entries.flow.async_init(
DOMAIN,
context={'source': SOURCE_IMPORT},
data=entry_config
)
)
return True
7. 集成开发实战：天气警报系统
7.1 项目概述
我们将构建一个完整的天气警报集成，实现以下功能：
- 从公共API获取天气数据
- 注册为Home Assistant服务
- 状态更新与事件发布
- 配置管理与版本迁移
7.2 完整代码实现
7.2.1 配置与初始化
# __init__.py
import asyncio
from datetime import timedelta
import logging
from homeassistant.config_entries import ConfigEntry
from homeassistant.core import HomeAssistant
from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
from .const import DOMAIN, CONF_API_KEY, CONF_UPDATE_INTERVAL, DEFAULT_UPDATE_INTERVAL
from .weather_api import WeatherAPI, WeatherAPIError
_LOGGER = logging.getLogger(__name__)
PLATFORMS = ["sensor", "binary_sensor"]
async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
"""设置天气警报集成"""
# 从配置获取API密钥
api_key = entry.data[CONF_API_KEY]
update_interval = entry.options.get(
CONF_UPDATE_INTERVAL, DEFAULT_UPDATE_INTERVAL
)
# 初始化API客户端
api = WeatherAPI(api_key)
# 创建数据更新协调器
coordinator = WeatherDataUpdateCoordinator(
hass,
api=api,
update_interval=timedelta(minutes=update_interval),
)
# 存储协调器和配置
hass.data.setdefault(DOMAIN, {})[entry.entry_id] = {
"coordinator": coordinator,
"api": api
}
# 加载初始数据
await coordinator.async_config_entry_first_refresh()
# 设置平台
await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
# 注册服务
async def handle_refresh_service(call):
"""手动刷新天气数据服务"""
_LOGGER.info("手动触发天气数据刷新")
await coordinator.async_request_refresh()
hass.services.async_register(
DOMAIN, "refresh_data", handle_refresh_service
)
return True
class WeatherDataUpdateCoordinator(DataUpdateCoordinator):
"""天气数据更新协调器"""
def __init__(self, hass, api, update_interval):
self.api = api
self.weather_data = None
super().__init__(
hass,
_LOGGER,
name=DOMAIN,
update_interval=update_interval,
)
async def _async_update_data(self):
"""获取天气数据"""
try:
data = await self.api.get_weather_forecast()
# 检测警报条件
if data.get("alert", False):
# 发布警报事件
self.hass.bus.async_fire(
f"{DOMAIN}_alert",
{
"alert_type": data["alert_type"],
"severity": data["severity"],
"message": data["alert_message"],
"timestamp": data["alert_time"]
}
)
# 调用通知服务
await self.hass.services.async_call(
"persistent_notification",
"create",
{
"title": f"天气警报: {data['alert_type']}",
"message": data["alert_message"],
"notification_id": f"{DOMAIN}_alert"
}
)
return data
except WeatherAPIError as err:
raise UpdateFailed(f"无法获取天气数据: {err}") from err
7.2.2 传感器平台实现
# sensor.py
from homeassistant.components.sensor import SensorEntity
from homeassistant.config_entries import ConfigEntry
from homeassistant.core import HomeAssistant
from homeassistant.helpers.entity import DeviceInfo
from homeassistant.helpers.update_coordinator import CoordinatorEntity
from .const import DOMAIN, MANUFACTURER, MODEL
async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry, async_add_entities):
"""设置天气传感器"""
coordinator = hass.data[DOMAIN][entry.entry_id]["coordinator"]
# 添加传感器实体
async_add_entities([
TemperatureSensor(coordinator, entry),
HumiditySensor(coordinator, entry),
PrecipitationSensor(coordinator, entry)
])
class WeatherSensor(CoordinatorEntity, SensorEntity):
"""天气传感器基类"""
def __init__(self, coordinator, entry):
super().__init__(coordinator)
self._entry_id = entry.entry_id
self._attr_device_info = DeviceInfo(
identifiers={(DOMAIN, entry.unique_id)},
name="天气警报系统",
manufacturer=MANUFACTURER,
model=MODEL,
sw_version="1.0.0"
)
@property
def available(self):
"""传感器可用性"""
return self.coordinator.data is not None
class TemperatureSensor(WeatherSensor):
"""温度传感器"""
def __init__(self, coordinator, entry):
super().__init__(coordinator, entry)
self._attr_unique_id = f"{entry.unique_id}_temperature"
self._attr_name = "室外温度"
self._attr_unit_of_measurement = "°C"
self._attr_icon = "mdi:thermometer"
self._attr_state_class = "measurement"
self._attr_device_class = "temperature"
@property
def state(self):
"""返回当前温度"""
return self.coordinator.data.get("temperature")
class HumiditySensor(WeatherSensor):
"""湿度传感器"""
def __init__(self, coordinator, entry):
super().__init__(coordinator, entry)
self._attr_unique_id = f"{entry.unique_id}_humidity"
self._attr_name = "室外湿度"
self._attr_unit_of_measurement = "%"
self._attr_icon = "mdi:water-percent"
self._attr_state_class = "measurement"
self._attr_device_class = "humidity"
@property
def state(self):
"""返回当前湿度"""
return self.coordinator.data.get("humidity")
class PrecipitationSensor(WeatherSensor):
"""降水量传感器"""
def __init__(self, coordinator, entry):
super().__init__(coordinator, entry)
self._attr_unique_id = f"{entry.unique_id}_precipitation"
self._attr_name = "今日降水量"
self._attr_unit_of_measurement = "mm"
self._attr_icon = "mdi:weather-rainy"
self._attr_state_class = "total_increasing"
self._attr_device_class = "precipitation"
@property
def state(self):
"""返回今日降水量"""
return self.coordinator.data.get("precipitation")
7.2.3 二进制传感器实现
# binary_sensor.py
from homeassistant.components.binary_sensor import (
BinarySensorEntity,
BinarySensorDeviceClass
)
from homeassistant.config_entries import ConfigEntry
from homeassistant.core import HomeAssistant
from homeassistant.helpers.update_coordinator import CoordinatorEntity
from .const import DOMAIN
async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry, async_add_entities):
"""设置天气警报二进制传感器"""
coordinator = hass.data[DOMAIN][entry.entry_id]["coordinator"]
async_add_entities([WeatherAlertBinarySensor(coordinator, entry)])
class WeatherAlertBinarySensor(CoordinatorEntity, BinarySensorEntity):
"""天气警报二进制传感器"""
def __init__(self, coordinator, entry):
super().__init__(coordinator)
self._entry_id = entry.entry_id
self._attr_unique_id = f"{entry.unique_id}_alert"
self._attr_name = "天气警报"
self._attr_device_class = BinarySensorDeviceClass.SAFETY
self._attr_icon = "mdi:alert-circle"
@property
def is_on(self):
"""返回是否有活跃警报"""
return self.coordinator.data.get("alert", False)
@property
def extra_state_attributes(self):
"""返回额外属性"""
if not self.coordinator.data or not self.is_on:
return {}
return {
"alert_type": self.coordinator.data.get("alert_type"),
"severity": self.coordinator.data.get("severity"),
"message": self.coordinator.data.get("alert_message"),
"alert_time": self.coordinator.data.get("alert_time")
}
8. 性能优化与最佳实践
8.1 API调用性能优化
| 优化策略 | 实现方法 | 性能提升 | 适用场景 |
|---|---|---|---|
| 批量操作 | 使用 asyncio.gather 并行调用 | 3-5倍 | 多设备同时控制 |
| 数据缓存 | @cached_property 缓存计算结果 | 减少90%重复计算 | 传感器属性计算 |
| 延迟加载 | 按需初始化组件 | 启动时间减少40% | 资源密集型集成 |
| 节流控制 | Throttle 装饰器限制调用频率 | API请求减少60% | 第三方API调用 |
8.2 代码示例：性能优化实现
# 使用缓存提高属性访问性能
from homeassistant.helpers.decorator import cached_property
class OptimizedSensor(SensorEntity):
"""优化性能的传感器示例"""
@cached_property
def battery_percentage(self):
"""缓存电池百分比计算结果"""
voltage = self.coordinator.data.get("voltage")
if voltage is None:
return None
# 复杂计算仅执行一次并缓存
return max(0, min(100, (voltage - 2.5) * 20))
# 使用节流控制API调用频率
from homeassistant.helpers.throttle import Throttle
class ThrottledWeatherAPI:
"""带节流控制的天气API客户端"""
def __init__(self, api_key):
self.api_key = api_key
self._session = aiohttp.ClientSession()
@Throttle(timedelta(minutes=5)) # 限制5分钟最多调用一次
async def get_weather_data(self, location):
"""获取天气数据，带节流控制"""
url = f"https://api.weather.com/data?key={self.api_key}&q={location}"
async with self._session.get(url) as response:
return await response.json()
# 使用并行调用加速多设备控制
async def control_all_lights(hass, turn_on=True):
"""并行控制所有灯光"""
# 获取所有灯光实体
light_entities = [
entity_id for entity_id in hass.states.async_entity_ids("light")
if "living" in entity_id
]
if not light_entities:
return
# 创建并行任务
service = "turn_on" if turn_on else "turn_off"
tasks = [
hass.services.async_call(
"light", service, {"entity_id": entity_id}, blocking=False
)
for entity_id in light_entities
]
# 并行执行
await asyncio.gather(*tasks)
_LOGGER.info(f"已{service} {len(light_entities)}个灯光设备")
8.3 错误处理最佳实践
async def robust_api_call(hass, retries=3):
"""健壮的API调用实现，带重试机制"""
backoff = ExponentialBackoff(initial_delay=1, factor=2, maximum=10)
for attempt in range(retries):
try:
return await hass.services.async_call(
"remote", "send_command",
{"entity_id": "remote.living_room", "command": "power_on"},
blocking=True, return_response=True
)
except ServiceNotFound:
_LOGGER.error("远程控制服务未找到")
return False
except Unauthorized:
_LOGGER.error("权限不足，无法执行操作")
return False
except Exception as err:
if attempt == retries - 1: # 最后一次尝试
_LOGGER.exception(f"API调用失败，已重试{retries}次")
raise
delay = backoff.exponential_delay(attempt)
_LOGGER.warning(f"API调用失败，{delay:.1f}秒后重试: {str(err)}")
await asyncio.sleep(delay)
return False
9. 安全最佳实践
9.1 认证与授权实现
from homeassistant.components import auth
from homeassistant.core import callback
async def async_setup_security(hass):
"""设置安全相关服务与权限"""
# 创建权限组
await auth.async_create_group(
hass,
name="home_automation_admins",
description="家庭自动化管理员",
policies=["can_control_security", "can_manage_devices"]
)
# 注册需要权限的服务
@callback
async def secure_service_handler(call):
"""需要特定权限的服务"""
user = await auth.async_get_user(hass, call.context.user_id)
if not user:
raise Unauthorized("用户不存在")
# 检查用户是否有权限
if not await auth.async_user_has_permission(
hass, user.id, "can_control_security"
):
raise Unauthorized(f"用户 {user.name} 无安全控制权限")
# 执行安全操作
_LOGGER.info(f"用户 {user.name} 执行了安全操作")
hass.services.async_register(
"security", "arm_system", secure_service_handler
)
10. 总结与进阶学习
10.1 核心知识点回顾
本文详细介绍了Home Assistant API的四大核心模块：
- 事件总线：实现组件间松耦合通信的基础
- 服务系统：封装可重用功能的标准接口
- 状态管理：跟踪与更新实体状态的核心机制
- 配置管理：处理集成生命周期与用户设置
10.2 进阶学习资源
- 官方文档：深入学习可访问Home Assistant开发者文档
- 社区集成：研究
homeassistant/components目录下的官方集成 - 代码示例库：查看
script/hassfest中的工具与示例代码 - 测试框架：学习
tests/目录下的单元测试与集成测试实现
10.3 下期预告
下一篇我们将探讨"Home Assistant高级自动化：使用机器学习预测家庭能源使用"，通过API集成TensorFlow模型实现智能能源管理。
如果觉得本文有价值，请点赞、收藏并关注，不错过更多Home Assistant开发技巧！
创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考
