node-red-contrib-alice 2.2.5 → 2.3.1

package/src/alice-togle.ts

@@ -0,0 +1,122 @@
+import { NodeAPI, Node } from "node-red";
+import { AliceCapabilityConfig, AliceDeviceNode, CapabilityState } from "./types.js";
+
+export = (RED: NodeAPI): void => {
+  function AliceToggle(this: Node, config: AliceCapabilityConfig): void {
+    RED.nodes.createNode(this, config);
+    const device = RED.nodes.getNode(config.device) as AliceDeviceNode;
+    device.setMaxListeners(device.getMaxListeners() + 1);
+
+    const ctype = 'devices.capabilities.toggle';
+    const instance = config.instance || '';
+    let response = config.response;
+    let value = false;
+
+    if (config.response === undefined) {
+      response = true;
+    }
+
+    this.status({ fill: "red", shape: "dot", text: "offline" });
+
+    const init = (): void => {
+      this.debug("Starting capability initilization ...");
+      const capab = {
+        type: ctype,
+        retrievable: true,
+        reportable: true,
+        parameters: {
+          instance: instance,
+        }
+      };
+      device.setCapability(this.id, capab)
+        .then(() => {
+          this.debug("Capability initilization - success!");
+          this.status({ fill: "green", shape: "dot", text: "online" });
+        })
+        .catch(err => {
+          this.error("Error on create capability: " + err.message);
+          this.status({ fill: "red", shape: "dot", text: "error" });
+        });
+    };
+
+    if (device.initState) init();
+
+    device.on("online", () => {
+      init();
+    });
+
+    device.on("offline", () => {
+      this.status({ fill: "red", shape: "dot", text: "offline" });
+    });
+
+    device.on(this.id, (val: boolean) => {
+      this.debug("Received a new value from Yandex...");
+      this.send({ payload: val });
+      const state: CapabilityState = {
+        type: ctype,
+        state: {
+          instance: instance,
+          value: val
+        }
+      };
+      if (response) {
+        this.debug("Automatic confirmation is true, sending confirmation to Yandex ...");
+        device.updateCapabState(this.id, state)
+          .then(() => {
+            value = val;
+            this.status({ fill: "green", shape: "dot", text: String(val) });
+          })
+          .catch(err => {
+            this.error("Error on update capability state: " + err.message);
+            this.status({ fill: "red", shape: "dot", text: "Error" });
+          });
+      }
+    });
+
+    this.on('input', (msg, _send, done) => {
+      if (typeof msg.payload != 'boolean') {
+        this.error("Wrong type! msg.payload must be boolean.");
+        if (done) { done(); }
+        return;
+      }
+      if (msg.payload === value) {
+        this.debug("Value not changed. Cancel update");
+        if (done) { done(); }
+        return;
+      }
+      const state: CapabilityState = {
+        type: ctype,
+        state: {
+          instance: instance,
+          value: msg.payload
+        }
+      };
+      device.updateCapabState(this.id, state)
+        .then(() => {
+          value = msg.payload as boolean;
+          this.status({ fill: "green", shape: "dot", text: String(msg.payload) });
+          if (done) { done(); }
+        })
+        .catch(err => {
+          this.error("Error on update capability state: " + err.message);
+          this.status({ fill: "red", shape: "dot", text: "Error" });
+          if (done) { done(); }
+        });
+    });
+
+    this.on('close', (removed: boolean, done: () => void) => {
+      if (removed) {
+        device.delCapability(this.id)
+          .then(() => { done(); })
+          .catch(err => {
+            this.error("Error on delete capability: " + err.message);
+            done();
+          });
+      } else {
+        done();
+      }
+    });
+  }
+
+  RED.nodes.registerType("Toggle", AliceToggle);
+};

package/src/alice-video.html

@@ -0,0 +1,90 @@
+<script type="text/javascript">
+    RED.nodes.registerType('Video',{
+        category: 'alice',
+        defaults:{
+            device: {value:"", type:"alice-device"},
+            name: {value:""},
+            protocol: { value:"hls" },
+            stream_url:{ value:"", required: true }
+        },
+        inputs:0,
+        outputs:0,
+        icon: "alice.png",
+        color: "#D8BFD8",
+        label: function(){
+            return this.name + ":video";
+        },
+        // oneditprepare: function(){
+        //     $("#node-input-protocol").typedInput({
+        //         types: [
+        //             {
+        //                 value: "protocol",
+        //                 options: [
+        //                     { value: "hls", label: "HLS"},
+        //                     { value: "progressive_mp4", label: "Progressive mp4"},
+        //                 ]
+        //             }
+        //         ]
+        //     });
+        // },
+        oneditsave: function(){
+            deivcename = $('#node-input-device option:selected').text();
+            $('#node-input-name').val(deivcename);
+        }
+    })
+</script>
+
+<script type="text/x-red" data-template-name="Video">
+    <input type="hidden" id="node-input-name">
+    <div class="form-row">
+        <label for="node-input-device">Device</label>
+        <input id="node-input-device">
+    </div>
+    <div class="form-row">
+        <label for="node-input-protocol">Protocol</label>
+        <input type="text" id="node-input-protocol" disabled>
+    </div>
+    <div class="form-row">
+        <label for="node-input-stream_url">URL</label>
+        <input type="text" id="node-input-stream_url">
+    </div>
+    <div class="form-tips" id="node-tip">
+        <span>Currently only supports the HLS stream protocol.<br>
+            Supported video codecs: H264.<br>
+            Maximum video resolution: 1920 x 1080.<br>
+            Supported audio codecs: AAC.
+        </span>
+    </div>
+</script>
+
+<script type="text/x-red" data-help-name="Video">
+    <p>Getting a video stream from a camera.</p>
+    
+    <h3>Property</h3>
+    <dl class="message-properties">
+        <dt>Device
+            <span class="property-type">Select</span>
+        </dt>
+        <dd> The device to which this feature is connected </dd>
+        <dt>Protocol
+            <span class="property-type">disabled</span>
+        </dt>
+        <dd>Currently only supports the HLS stream protocol.<br>
+            Supported video codecs: H264.<br>
+            Maximum video resolution: 1920 x 1080.<br>
+            Supported audio codecs: AAC.</dd>
+        <dt>URL
+            <span class="property-type">string</span>
+        </dt>
+        <dd>Stream URL with parameters.<br>
+            The URL must be accessible from the Internet<br>
+            In response to a request for a stream using this link, you need to pass headers:<br>
+            Content-type: application/vnd.apple.mpegurl<br>
+            Access-Control-Allow-Origin: https://yastatic.net</dd>
+    </dl>
+
+    <h3>References</h3>
+        <ul>
+            <li><a href="https://yandex.ru/dev/dialogs/smart-home/doc/concepts/video_stream.html"> - Yandex documentation</a></li>
+        </ul>
+    </script>

package/src/alice-video.ts

@@ -0,0 +1,99 @@
+import { NodeAPI, Node } from "node-red";
+import { AliceVideoConfig, AliceDeviceNode, CapabilityState } from "./types.js";
+
+export = (RED: NodeAPI): void => {
+  function AliceVideo(this: Node, config: AliceVideoConfig): void {
+    RED.nodes.createNode(this, config);
+    const device = RED.nodes.getNode(config.device) as AliceDeviceNode;
+    device.setMaxListeners(device.getMaxListeners() + 1);
+
+    const id = this.id;
+    const ctype = 'devices.capabilities.video_stream';
+    const instance = 'get_stream';
+    const stream_url = config.stream_url;
+    const protocol = config.protocol;
+
+    const curentState: CapabilityState = {
+      type: ctype,
+      state: {
+        instance: instance,
+        value: {
+          stream_url: stream_url,
+          protocol: protocol
+        }
+      }
+    };
+
+    this.status({ fill: "red", shape: "dot", text: "offline" });
+
+    const init = (): void => {
+      this.debug("Starting capability initilization ...");
+      const capab = {
+        type: ctype,
+        retrievable: false,
+        reportable: false,
+        parameters: {
+          instance: instance,
+          protocols: [protocol]
+        }
+      };
+
+      device.setCapability(id, capab)
+        .then(() => {
+          this.debug("Capability initilization - success!");
+          this.status({ fill: "green", shape: "dot", text: "online" });
+        })
+        .catch(err => {
+          this.error("Error on create capability: " + err.message);
+          this.status({ fill: "red", shape: "dot", text: "Error" });
+        });
+
+      device.updateCapabState(id, curentState)
+        .then(() => {
+          this.status({ fill: "green", shape: "dot", text: "online" });
+        })
+        .catch(err => {
+          this.error("Error on update capability state: " + err.message);
+          this.status({ fill: "red", shape: "dot", text: "Error" });
+        });
+    };
+
+    if (device.initState) init();
+
+    device.on("online", () => {
+      init();
+    });
+
+    device.on("offline", () => {
+      this.status({ fill: "red", shape: "dot", text: "offline" });
+    });
+
+    device.on(id, () => {
+      device.updateCapabState(id, curentState)
+        .then(() => {
+          const str_url = stream_url.slice(0, 25) + "...";
+          this.status({ fill: "green", shape: "dot", text: str_url });
+        })
+        .catch(err => {
+          this.error("Error on update capability state: " + err.message);
+          this.status({ fill: "red", shape: "dot", text: "Error" });
+        });
+    });
+
+    this.on('close', (removed: boolean, done: () => void) => {
+      device.setMaxListeners(device.getMaxListeners() - 1);
+      if (removed) {
+        device.delCapability(id)
+          .then(() => { done(); })
+          .catch(err => {
+            this.error("Error on delete capability: " + err.message);
+            done();
+          });
+      } else {
+        done();
+      }
+    });
+  }
+
+  RED.nodes.registerType("Video", AliceVideo);
+};