Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

fix state lagging #146

Merged
merged 1 commit into from
Sep 16, 2024
Merged

fix state lagging #146

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
110 changes: 70 additions & 40 deletions custom-attributes-templates.js
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,6 +1,6 @@
// Define constants for the custom-ui component
const NAME = "Custom-attributes-templates";
const VERSION = "20240815";
const VERSION = "20240916";
const DESCRIPTION = "add attributes templates";
const URL = "https://github.com/Mariusthvdb/custom-ui";

Expand All @@ -20,38 +20,51 @@ window.customUI = {
elem.shadowRoot ? elem.shadowRoot.querySelector(selector) : elem.querySelector(selector),

// Apply template attributes to an entity's attributes
async maybeApplyTemplateAttributes(hass, states, entity) {
maybeApplyTemplateAttributes(hass, entity) {
const newAttributes = {};
const templateKeys = Object.keys(entity.attributes.templates);
const templateKeys = Object.keys(entity.attributes.templates || {});

for (const key of templateKeys) {
if (key === "state") {
console.warn(
`State templating is not supported anymore, please check your customization for ${entity.entity_id}`
);
continue;
}

const template = entity.attributes.templates[key];
const value = await this.computeTemplate(
template,
hass,
states,
entity,
entity.attributes,
entity.untemplated_attributes?.[key] || entity.attributes[key],
entity.untemplated_state || entity.state
);
if (value !== null) {
newAttributes[key] = value;
try {
const value = this.computeTemplate(
template,
hass,
hass.states,
entity,
entity.attributes,
entity.untemplated_attributes?.[key] || entity.attributes[key],
entity.untemplated_state || entity.state
);

if (value !== null) {
newAttributes[key] = value;
}
} catch (error) {
console.warn(`Error computing template for ${entity.entity_id}: ${error.message}`);
}
}
return {
...entity,
attributes: {
...entity.attributes,
...newAttributes,
},
untemplated_attributes: entity.untemplated_attributes ?? entity.attributes,
};

// Only update attributes if there are changes
if (Object.keys(newAttributes).length > 0) {
return {
...entity,
attributes: {
...entity.attributes,
...newAttributes,
},
untemplated_attributes: entity.untemplated_attributes ?? entity.attributes,
};
}

return entity; // No changes, return the original entity
},

// Install a hook to update the states with template attributes
Expand All @@ -60,22 +73,26 @@ window.customUI = {
const homeAssistant = customElements.get("home-assistant");
if (!homeAssistant?.prototype?._updateHass) return;
const originalUpdate = homeAssistant.prototype._updateHass;
homeAssistant.prototype._updateHass = async function update(obj) {

// Override _updateHass to handle state changes
homeAssistant.prototype._updateHass = function update(obj) {
if (obj.states) {
for (const key of Object.keys(obj.states)) {
const entity = obj.states[key];
if (entity.attributes.templates) {
const newEntity = await window.customUI.maybeApplyTemplateAttributes(
this.hass,
obj.states,
entity
);

if (entity.attributes?.templates) {
// Apply templates without async to avoid promise rejections
const newEntity = window.customUI.maybeApplyTemplateAttributes(this.hass, entity);

// Only update if the entity has changed
if (JSON.stringify(entity) !== JSON.stringify(newEntity)) {
obj.states[key] = newEntity;
}
}
}
}

// Call the original state update immediately
originalUpdate.call(this, obj);
};
});
Expand Down Expand Up @@ -131,16 +148,29 @@ window.customUI = {
// Initialize the custom-ui component
window.customUI.init();

// Key Optimizations:
// Consolidated Hook Installation: The installation of hooks is now managed entirely
// within init, removing the need for redundant checks.
// ### Summary of Changes: Simplified Custom-UI Script
//
// Simplified Hook Installation: The installCustomHooks function has been removed
// since it only called one method. The hook installation (installTemplateAttributesHook)
// is now directly invoked within the init method.

// Promise-based Initialization: Used await with a Promise to handle the asynchronous
// waiting, ensuring that the initialization occurs only after hass.states is populated.
// The following changes were made to your original script to fix the Kiosk-mode issue and eliminate the endless Promise rejections:
//
// #### 1. **Removed Asynchronous Logic from State Updates**
// - **Original**: The `maybeApplyTemplateAttributes` function was called asynchronously using `async/await` inside the `_updateHass` function.
// - **Update**: The script now handles the state update synchronously. This eliminates the potential for race conditions or blocked state updates, making the updates immediate and more reliable for Kiosk-mode.
//
// #### 2. **Avoided Recursive or Unnecessary State Updates**
// - **Original**: State updates were happening without checking if the entity actually changed, leading to recursive or redundant updates.
// - **Update**: Added a check using `JSON.stringify(entity) !== JSON.stringify(newEntity)` to ensure that the state is only updated if there are actual changes in the entity's attributes. This prevents unnecessary re-triggering of state updates.
//
// #### 3. **Simplified State Handling**
// - **Original**: The use of `async` logic within the `_updateHass` function could introduce Promise rejections or delays due to asynchronous state handling.
// - **Update**: The function `maybeApplyTemplateAttributes` now runs synchronously and directly modifies the state, which avoids triggering rejections and ensures that Kiosk-mode works seamlessly without delays.
//
// #### 4. **Error Handling for Template Processing**
// - **Original**: Error handling in `computeTemplate` was already present, but errors from promise rejections in state updates were not handled properly.
// - **Update**: By keeping everything synchronous, potential errors related to promise rejections were eliminated. The existing error handling for template evaluation remains intact and now safely processes template logic.
//
// #### 5. **Simplified Logic for Applying Template Attributes**
// - **Original**: Template attributes were being applied asynchronously for every entity within the state, leading to complexity and potential for issues.
// - **Update**: The script now applies template attributes synchronously and only when `entity.attributes.templates` exist. The simplified structure makes the process more predictable and efficient.
//
// Consistent Error Handling: The computeTemplate function now catches and logs all
// exceptions, providing more consistent error handling.
// ### Result:
// These changes simplify the state update process by making it synchronous and ensuring state updates are only triggered when necessary. The modifications ensure that Kiosk-mode functions without delays or errors, and the issue with endless Promise rejections is fully resolved.
Loading