A collection of extensions and utilities for managing Home Assistant light entities, providing advanced color handling, simpler state representation, and generic scenes.
CodeCasa.NetDaemon.Notifications.Phone
This library provides the PhoneNotificationEntity class, making it easy to create, update, and manage phone notifications in Home Assistant.
Features include:
Easy notification creation and updating.
Support for actionable notifications with customizable buttons.
Support for Android and iOS.
Usage
Define an entity for a specific phone:
public class JasperPhoneNotifications(NotifyServices notificationServices, IHaContext haContext)
: PhoneNotificationEntity(haContext, notificationServices.MobileAppPixel7);
Use it to send notifications (with optional actions):
[NetDaemonApp]
internal class Example
{
public Example(
LightEntities lightEntities,
JasperPhoneNotifications jasperPhoneNotifications)
{
var notificationId = $"{nameof(Example)}_Notification"; // Note: Using an ID that is consistent between runs also ensures that old notifications are removed/replaced on phones when the app is reloaded.
lightEntities.OfficeLights.SubscribeOnOff(
() =>
{
jasperPhoneNotifications.Notify(new AndroidNotificationConfig
{
Message = "Hey Jasper, the office lights are on!",
StatusBarIcon = "mdi:lightbulb",
Actions =
[
new(() => lightEntities.OfficeLights.TurnOff(), "Click here to turn them off.")
]
}, notificationId);
},
() => jasperPhoneNotifications.RemoveNotification(notificationId));
}
}
This automation sends a notification to Jasper’s phone whenever the office lights are turned on. The notification includes a button that allows him to turn off the lights directly from the notification:
This library helps you turn a Home Assistant Dropdown/InputSelect helper entity into a dynamic notifications list.
I always liked Android’s dynamic notifications and wished for something similar in Home Assistant. While HA has a built‑in notification panel, it’s limited and somewhat hidden away. I wanted to display rich, actionable notifications directly on my own dashboard—without too much hassle.
Originally built as a quick solution, this implementation worked so well that I decided to share it. It stores notifications as JSON entries in an input_select entity, including fields like message, icon, color, and actions. The library handles adding, updating, removing, and even executing actions for you.
One of the biggest upsides of this approach is that it keeps everything inside Home Assistant itself: your notifications persist in the state of the input_select entity, surviving reboots or refreshes.
You can render these notifications in a custom UI (like my Blazor dashboard) or even with native Home Assistant templating.
By default, the library uses a standard JSON format for entries, but you can define your own if needed.
Usage
First, update your appsettings.json with an InputSelectNotificationEntities array containing the input select entities you want to use as notification lists.
Optionally, you can add an InputNumberEntityId to store the current notification count (handy for templating in dashboards):
Note: As an alternative, you can also provide configuration directly in code when calling AddInputSelectNotifications.
Inject the corresponding IInputSelectNotificationEntity service using the input select entity ID as the key, and use it to create, update, or remove notifications:
[NetDaemonApp]
internal class Example
{
public Example([FromKeyedServices("input_select.living_room_panel_notifications")] IInputSelectNotificationEntity livingRoomPanelDashboardNotifications)
{
var notificationId = $"{nameof(Example)}_Notification";
livingRoomPanelDashboardNotifications.Notify(new InputSelectDashboardNotificationConfig
{
Message = "This is a notification.",
SecondaryMessage = "Click me to delete me!.",
Icon = "mdi:lightbulb",
IconColor = Color.Yellow,
Action = () => livingRoomPanelDashboardNotifications.RemoveNotification(notificationId)
}, notificationId);
}
}
Alternatively, you can wrap it in the provided InputSelectNotificationEntity class and register that instead:
public class LivingRoomPanelDashboardNotifications(
[FromKeyedServices("input_select.living_room_panel_notifications")] IInputSelectNotificationEntity inputSelectNotifications)
: InputSelectNotificationEntity(inputSelectNotifications);
Then inject and use it just like any other service:
[NetDaemonApp]
internal class Example
{
public Example(LivingRoomPanelDashboardNotifications livingRoomPanelDashboardNotifications)
{
...
}
}
Finally, to trigger an action, make sure to raise the following event:
HaContext.SendEvent("notification_clicked", new { notificationEntity = InputSelectEntities.LivingRoomPanelNotifications.EntityId, notificationIndex = index });
To display the notification using native Home Assistant templating, please follow this setup guide. Result:
This library provides the NetDaemonRuntimeStateService, which allows you to check and subscribe to the runtime state of NetDaemon.
While this service isn’t necessary when using NetDaemonApp classes for automations, it can be useful in contexts where you access NetDaemon entities outside of that scope — for example, in a (Blazor) UI or background service. In such cases, NetDaemonRuntimeStateService helps determine whether the NetDaemon runtime is initialized and connected.
Runtime States
The service exposes three possible states:
Initializing – NetDaemon is still initializing and building its state cache. Entity access is not yet available.
Connected – NetDaemon is connected to Home Assistant.
Disconnected – NetDaemon is disconnected from Home Assistant. Cached entity states remain available, but no updates will be received until reconnected.
Strongly-typed wrappers for Home Assistant entities in NetDaemon.
This library provides EnumEntity, which enables entities with enum-based states.
You can configure it by:
Supplying only the enum type (defaults to enum names as state values)
Providing an enum-to-string dictionary
Supplying custom Func<TEnum, string> and Func<string, TEnum?> conversion functions
Usage
With auto-generated NetDaemon entities, you can create type-safe variants.
For example, here’s a type-safe input_select entity:
Base Class (optional)
public record TypeSafeInputSelectEntity<T> : EnumEntity<T, TypeSafeInputSelectEntity<T>, EnumEntityState<T, InputSelectAttributes>, InputSelectAttributes>, IInputSelectEntityCore
where T : struct, Enum
{
public TypeSafeInputSelectEntity(IHaContext haContext, string entityId) : base(haContext, entityId)
{
}
public TypeSafeInputSelectEntity(IEntityCore entity) : base(entity)
{
}
}
Concrete Wrapper Example
public record PersonStateEntity : TypeSafeInputSelectEntity<PersonStates>
{
public PersonStateEntity(InputSelectEntity inputSelectEntity)
: base(inputSelectEntity)
{
}
}
public enum PersonStates
{
Awake,
Asleep,
Away
}
Now, PersonStateEntity can be used as a wrapper for any InputSelectEntity that has the states Awake, Asleep and Away.
Another Example: PersonEntity
The person entity can be in states like home, not_home, or a zone name.
If you don’t want to sync all zone names, you can use the Func constructor overload to fall back to NotHome:
public record TypeSafePersonEntity : EnumEntity<PersonEntityStates, TypeSafePersonEntity, EnumEntityState<PersonEntityStates, PersonAttributes>, PersonAttributes>, IPersonEntityCore
{
private static readonly Dictionary<PersonEntityStates, string> PeopleEntityStatesToStateValues = new()
{
{ PersonEntityStates.Home , "home" },
{ PersonEntityStates.NotHome , "not_home" }
{ PersonEntityStates.Store , "store" }
};
public static readonly Dictionary<string, PersonEntityStates> StateValuesToPeopleEntityStates = PeopleEntityStatesToStateValues.Inverse(StringComparer.OrdinalIgnoreCase);
public TypeSafePersonEntity(IHaContext haContext, string entityId)
: base(haContext, entityId,
e => PeopleEntityStatesToStateValues[e],
v => StateValuesToPeopleEntityStates.GetValueOrDefault(v, PersonEntityStates.NotHome)) // By using GetValueOrDefault, any zone outside home will result in state NotHome.
{
}
public TypeSafePersonEntity(IEntityCore entity)
: base(entity,
e => PeopleEntityStatesToStateValues[e],
v => StateValuesToPeopleEntityStates.GetValueOrDefault(v, PersonEntityStates.NotHome))
{
}
}
public enum PersonEntityStates
{
Home,
NotHome,
Store
}
Create a stateful IObservable<bool> from the sun entity Sun which emits true when Elevation is smaller than curtainCloseSunElevation, false otherwise. Stateful in this context means that the observable will immediately emit the current value returned from the predicate when an observer is subscribed. (internally, the NetDaemon extension methods StateChangesWithCurrent and StateAllChangesWithCurrent are used for this.)
SubscribeTrueFalse is an extension method on IObservable<bool> that assigns an action for when true is emitted as well as when false is emitted.
This implementation will immediately open or close the covers depending on the initial result of the predicate as well as update whenever the result of the predicate changes.
Boolean Observables
This library contains a set of extension methods to convert entities to implementations of IObservable<bool>. If no predicate is provided, the On state is mapped to true, the Off state is mapped to false.
The usage of ToBooleanObservable (or one of the aliases ToOnOffObservable or ToOpenClosedObservable) on an entity will use StateChanges (or StateAllChanges when a predicate is provided) to result in a stateful IObservable<bool>.
In case a stateful observable is not desired, the method ToChangesOnlyBooleanObservable can be used.
The use of stateful IObservable<bool> implementations enables the use of logic operators and scheduling extensions provided by the Reactive.Boolean library. This allows for improved readability of implementations.
For a more detailed documentation on extension methods for IObservable<bool>, check out the documentation for Reactive.Booleanhere.
Example
The following example shows the usage of boolean (Not, Or and And) and scheduling (LimitTrueDuration) logic to write a complex automation that is still easy to understand and will trigger on startup.
var noOneAsleep = inputBooleanEntities.JasperAsleep.ToBooleanObservable()
.Or(inputBooleanEntities.AnonAsleep.ToBooleanObservable()).Not();
var closetDoorOpenShorterThanOneMin = binarySensorEntities.BedroomClosetDoorSensorContact
.ToOpenClosedObservable().LimitTrueDuration(TimeSpan.FromMinutes(5), scheduler);
noOneAsleep.And(closetDoorOpenShorterThanOneMin).BindToOnOff(lightEntities.ClosetLight);
Note that even though scheduling is mostly handled by the Reactive.Boolean library, knowledge of the Entity does improve some scheduling methods. In the cases of WhenTrueFor and LimitTrueDuration both LastChanged and the passing of time are used to evaluate whether a true is emitted.
Scheduling
A breakdown of all scheduling extension methods this library enables for Entity and IObservable<bool>:
OnForAtLeast
Returns an observable that won't emit false for at least the provided timespan after an initial on (true) is emitted by the entity.
If a false is emitted during the provided timespan, it will be emitted immediately after the timer is completed.
Example Use Case
Turn on a light for at least 3 seconds after a button was pressed. If 3 seconds are passed, only keep it on if the button is still being pressed, but immediately turn if off if not.
// buttonPressed is a IObservable<bool>
var buttonPressed = buttonEntity.ToBooleanObservable(s => s.State == "pressed");
buttonPressed
.TrueForAtLeast(TimeSpan.FromSeconds(3), scheduler)
.BindToOnOff(lightEntity);
Aliases: OpenForAtLeast/TrueForAtLeast.
PersistOnFor
Returns an observable that delays the first off (false) that is emitted after an on (true) by the entity for a duration of the provided timespan.
Example Use Case
Keep a light on for 3 more seconds after last motion was detected.
// motionDetected is a IObservable<bool>
var motionDetected = motionSensorEntity.ToBooleanObservable(s => s.State == "motion");
motionDetected
.PersistTrueFor(TimeSpan.FromSeconds(3), scheduler)
.BindToOnOff(lightEntity);
Aliases: PersistOpenFor/PersistTrueFor.
WhenOnFor
Returns an observable that emits true once entity does not emit off (false) for a minimum of the provided timespan.
When called on an Entity, this method takes into account EntityState.LastChanged, meaning the returned observable can emit true even if the time did not pass during runtime.
Example Use Case
Send notification when washing machine power has been 0 for at least 1 minute.
// washingMachineCurrentIsZero is a IObservable<bool>
var washingMachineCurrentIsZero = washingMachineCurrentEntity.ToBooleanObservable(s => s.State == 0);
washingMachineCurrentIsZero
.WhenTrueFor(TimeSpan.FromMinutes(1), scheduler)
.SubscribeTrue(() => notificationEntity.Send("Washing machine is done!"));
Aliases: WhenOpenFor/WhenTrueFor.
LimitOnDuration
Returns an observable that will automatically emit false if the entity does not emit an off (false) itself within the provided timespan after emitting on (true).
When called on an Entity, this method takes into account EntityState.LastChanged, meaning the returned observable can emit false even if the time did not pass during runtime.
Example Use Case
Keep closet lights on for a maximum amount of time.
// closetDoorOpen is a IObservable<bool>
var closetDoorOpen = closetDoorEntity.ToBooleanObservable(s => s.State == "open");
closetDoorOpen
.LimitTrueDuration(TimeSpan.FromMinutes(2), scheduler)
.BindToOnOff(closetLightEntity);
Aliases: LimitOpenDuration/LimitCloseDuration.
Unavailability of entities
This library also implements the utility method RepeatWhenEntitiesBecomeAvailable<T>. This method can be called on a IObservable<T> to repeat a value when one of the provided entities become available.
Example
The following example will re-apply the correct state as soon as the plug becomes available (is plugged in).
const int nightTimeSunElevation = 0;
var nightTime = sunEntities.Sun
.ToBooleanObservable(e => e.Attributes?.Elevation <= nightTimeSunElevation);
nightTime
.RepeatWhenEntitiesBecomeAvailable(switchEntities.LivingRoomChristmasTreeLights)
.BindToOnOff(switchEntities.LivingRoomChristmasTreeLights);
CodeCasa.NetDaemon.Lights
A collection of extensions and utilities for managing Home Assistant light entities, providing advanced color handling, simpler state representation, and generic scenes.
Features include:
LightParameters – A simple, state-focused representation of light configuration (brightness, RGB color, color temperature) instead of low-level turn-on parameters.
LightTransition – Combines LightParameters with optional transition duration for smooth color or brightness changes.
Automatic Color Mode Detection – Intelligently translates LightParameters to the correct underlying Home Assistant API calls based on each light's actual capabilities.
Light Scene Templates – Pre-built scenes (Relax, NightLight, Concentrate, Bright, Dimmed) that automatically adapt to any light's supported features.
Light Flattening & Inspection – Utilities to inspect light state and flatten light groups into individual entities.
Please note that this library is primarily designed for my own use. It may contain untested edge cases and might not work with all types of light devices.
Overview
The main goal of this library is to abstract away the complexity of Home Assistant's light entity API. Instead of dealing with device-specific capabilities and conditional logic in your automations, you work with LightParameters that describe what state you want—and the library handles how to achieve it.
For example, you can apply the same "Relax" scene to any light—whether it supports color temperature, RGB colors, or only brightness—and get appropriate results for each device. Similarly, you can create a transition from one set of parameters to another without worrying about whether the light supports color modes or requires fallback brightness handling.
Usage
Working with Light Parameters
Create light parameters to represent desired states:
var brightParams = new LightParameters { Brightness = 255 };
var warmDimmed = new LightParameters { ColorTemp = 366, Brightness = 100 };
var colorful = new LightParameters { RgbColor = Color.Red, Brightness = 200 };
Use predefined states for off and on:
var off = LightParameters.Off(); // Brightness = 0
var on = LightParameters.On(); // Useful for binary lights
Light Transitions
Convert parameters to transitions and apply them:
var transition = brightParams.AsTransition(); // Uses default transition.
lightEntities.KitchenLight.ExecuteLightTransition(transition);
// With a custom transition duration:
var smoothTransition = warmDimmed.AsTransition(TimeSpan.FromSeconds(3));
lightEntities.BedroomLight.ExecuteLightTransition(smoothTransition);
Blending Parameters
Blend two sets of parameters together for smooth transitions or animations:
var morning = new LightParameters { ColorTemp = 366, Brightness = 100 };
var evening = new LightParameters { RgbColor = Color.Red, Brightness = 200 }; // Blending is possible between different parameter types.
var transitionPercent = 0.7; // 70% towards evening
var blended = morning.Interpolate(evening, transitionPercent);
lightEntities.LivingRoomLight.ExecuteLightTransition(blended.AsTransition());
Using Light Scenes
Apply pre-built scene templates that adapt to each light's capabilities:
foreach (var light in lightEntities.EnumerateAll())
{
light.TurnOn(LightSceneTemplates.Concentrate);
}
Inspecting Light State
Get the current parameters of a light:
var currentState = lightEntities.KitchenLight.GetLightParameters();
Console.WriteLine($"Brightness: {currentState.Brightness}, Color Temp: {currentState.ColorTemp}");
var brightness = lightEntities.BedroomLight.GetBrightness();
Check if a light matches expected parameters:
if (lightEntities.OfficeLight.SceneEquals(LightSceneTemplates.Bright(lightEntities.OfficeLight)))
{
Console.WriteLine("Office light is in Bright scene!");
}
Working with Light Groups
Flatten light groups to get individual entities:
var groupLight = lightEntities.AllLights; // A light group entity
var individualLights = groupLight.Flatten();
// Now apply transitions to each light separately
foreach (var light in individualLights)
{
light.ExecuteLightTransition(warmDimmed.AsTransition());
}
Available Scenes:
Relax – Warm color temperature with medium brightness for relaxing environments
NightLight – Very warm color temperature with very low brightness for bedtime
Concentrate – Cool/neutral color temperature with high brightness for focus
Bright – Warm color temperature with maximum brightness for general illumination
Dimmed – Warm color temperature with low brightness for ambient lighting
