xiaomihome/xiaomi/classify.go

package xiaomi

import (
	"sort"
	"strings"
)

// deviceTypeToKind maps SPEC URN device types to Kind.
// URN format: urn:miot-spec-v2:device:{TYPE}:...
var deviceTypeToKind = map[string]Kind{
	"air-conditioner":      KindAirConditioner,
	"air-condition-outlet": KindAirConditioner,
	"air-condition-eco":    KindAirConditioner,
	"airer":                KindAirConditioner,
	"ac-partner":           KindAirConditioner,
	"light":                KindLight,
	"lightbulb":            KindLight,
	"night-light":          KindLight,
	"ceiling-light":        KindLight,
	"switch":               KindSwitch,
	"powerstrip":           KindSwitch,
	"toggle-switch":        KindSwitch,
	"wireless-switch":      KindSwitch,
	"curtain-switch":       KindSwitch,
	"fan":                  KindFan,
	"ceiling-fan":          KindFan,
	"ventilator":           KindFan,
	"air-fresh":            KindFan,
	"air-purifier":         KindFan,
	"curtain":              KindCover,
	"airer-rack":           KindCover,
	"humidifier":           KindHumidifier,
	"dehumidifier":         KindHumidifier,
	"humidifier-dehumidifier": KindHumidifier,
	"vacuum":               KindVacuum,
	"sweeper":              KindVacuum,
	"robot-cleaner":        KindVacuum,
	"water-heater":         KindWaterHeater,
	"water-cooler":         KindWaterHeater,
	"kettle":               KindWaterHeater,
	"heater":               KindAirConditioner,
	"electric-blanket":     KindAirConditioner,
	"thermostat":           KindAirConditioner,
	"speaker":              KindSpeaker,
	"bluetooth-speaker":    KindSpeaker,
	"alarm-clock":          KindSpeaker,
	"media-player":         KindSpeaker,
	"playback":             KindSpeaker,
	"music":                KindSpeaker,
	"gateway":              KindGateway,
	"plug":                 KindPlug,
	"outlet":               KindPlug,
	"sensor-occupy":        KindOccupancySensor,
	"sensor_occupy":        KindOccupancySensor,
	"occupancy-sensor":     KindOccupancySensor,
	"occupancy_sensor":     KindOccupancySensor,
	"motion-sensor":        KindOccupancySensor,
	"motion_sensor":        KindOccupancySensor,
	"magnet":               KindOccupancySensor,
	"sensor":               KindSensor,
	"sensor-ht":            KindSensor,
	"sensor_ht":            KindSensor,
	"sensor-temp":          KindSensor,
	"sensor_temp":          KindSensor,
	"sensor-humidity":      KindSensor,
	"sensor_humidity":      KindSensor,
	"illumination":         KindSensor,
	"sensor-smoke":         KindSensor,
	"sensor_gasm":          KindSensor,
	"sensor-gasm":          KindSensor,
}

// classifyKeys 按长度降序排列的 key，保证长/具体 key 先匹配（如 sensor-occupy 先于 sensor）。
var classifyKeys = func() []string {
	keys := make([]string, 0, len(deviceTypeToKind))
	for k := range deviceTypeToKind {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return len(keys[i]) > len(keys[j]) })
	return keys
}()

// Classify 从 DeviceInfo 判断设备种类。
// 优先从 URN 的 device type 段精确提取，降至 model 子串匹配。
func Classify(info *DeviceInfo) Kind {
	if info == nil {
		return KindUnknown
	}

	// 从 URN 精确解析 device type
	if k := classifyByURN(info.URN); k != KindUnknown {
		return k
	}

	// 降至 model 匹配
	if k := classifyByModel(info.Model); k != KindUnknown {
		return k
	}

	return KindUnknown
}

// classifyByURN 从 URN 中提取 device type 并映射 Kind。
func classifyByURN(urn string) Kind {
	parts := strings.Split(urn, ":")
	if len(parts) >= 4 && parts[2] == "device" {
		if k, ok := deviceTypeToKind[parts[3]]; ok {
			return k
		}
	}
	return KindUnknown
}

// classifyByModel 对 model 字符串做子串匹配（用于无 URN 或 URN 不标准时）。
// 按 key 长度降序匹配，保证 sensor-occupy 先于 sensor。
func classifyByModel(model string) Kind {
	model = strings.ToLower(model)
	for _, t := range classifyKeys {
		if strings.Contains(model, t) {
			return deviceTypeToKind[t]
		}
	}
	return KindUnknown
}

// FilterByKind 按设备种类过滤。
func FilterByKind(kind Kind) DeviceFilter {
	return func(d *DeviceInfo) bool { return d.DeviceKind() == kind }
}

// Or 返回任意一个 filter 满足即通过的组合过滤器。
func Or(filters ...DeviceFilter) DeviceFilter {
	return func(d *DeviceInfo) bool {
		for _, f := range filters {
			if f(d) {
				return true
			}
		}
		return false
	}
}