Properly handle EndPoints

Author: jdomnitz

ZWaveDotNet/CommandClasses/MultiChannel.cs

@@ -20,12 +20,18 @@
 
 namespace ZWaveDotNet.CommandClasses
 {
+    /// <summary>
+    /// The Multi Channel Command Class is used to address one or more End Points in a Multi Channel device.
+    /// </summary>
     [CCVersion(CommandClass.MultiChannel, 1, 4)]
     public class MultiChannel : CommandClassBase
     {
+        /// <summary>
+        /// Unsolicited End Point Capabilities Report
+        /// </summary>
         public event CommandClassEvent<EndPointCapabilities>? EndpointCapabilitiesUpdated;
 
-        public enum MultiChannelCommand
+        enum MultiChannelCommand
         {
             EndPointGet = 0x07,
             EndPointReport = 0x08,
@@ -39,6 +45,12 @@ public enum MultiChannelCommand
         }
         internal MultiChannel(Node node, byte endpoint) : base(node, endpoint, CommandClass.MultiChannel) {  }
 
+        /// <summary>
+        /// <b>Version 3</b>: Query the number of End Points implemented by the receiving node
+        /// </summary>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        /// <exception cref="MethodAccessException"></exception>
         public async Task<EndPointReport> GetEndPoints(CancellationToken cancellationToken = default)
         {
             if (node.ID == Node.BROADCAST_ID)
@@ -47,6 +59,13 @@ public async Task<EndPointReport> GetEndPoints(CancellationToken cancellationTok
             return new EndPointReport(response.Payload.Span);
         }
 
+        /// <summary>
+        /// <b>Version 3</b>: Query the non-secure Command Class capabilities of an End Point
+        /// </summary>
+        /// <param name="endpointId"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        /// <exception cref="MethodAccessException"></exception>
         public async Task<EndPointCapabilities> GetCapabilities(byte endpointId, CancellationToken cancellationToken = default)
         {
             if (node.ID == Node.BROADCAST_ID)
@@ -55,6 +74,14 @@ public async Task<EndPointCapabilities> GetCapabilities(byte endpointId, Cancell
             return new EndPointCapabilities(response.Payload.Span);
         }
 
+        /// <summary>
+        /// <b>Version 3</b>: Request End Points having a specific GenericType or SpecificType.
+        /// </summary>
+        /// <param name="generic"></param>
+        /// <param name="specific"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        /// <exception cref="MethodAccessException"></exception>
         public async Task<EndPointFindReport> FindEndPoints(GenericType generic, SpecificType specific, CancellationToken cancellationToken = default)
         {
             if (node.ID == Node.BROADCAST_ID)
@@ -63,6 +90,13 @@ public async Task<EndPointFindReport> FindEndPoints(GenericType generic, Specifi
             return new EndPointFindReport(response.Payload.Span);
         }
 
+        /// <summary>
+        /// <b>Version 4</b>: This command is used to query the members of an Aggregated End Point.
+        /// </summary>
+        /// <param name="endpointId"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        /// <exception cref="MethodAccessException"></exception>
         public async Task<List<byte>> GetAggregatedMembers(byte endpointId, CancellationToken cancellationToken = default)
         {
             if (node.ID == Node.BROADCAST_ID)

ZWaveDotNet/Entities/EndPoint.cs

@@ -13,7 +13,9 @@
 using System.Collections.ObjectModel;
 using System.Reflection;
 using ZWaveDotNet.CommandClasses;
+using ZWaveDotNet.CommandClasses.Enums;
 using ZWaveDotNet.CommandClassReports.Enums;
+using ZWaveDotNet.Entities.JSON;
 using ZWaveDotNet.Enums;
 using ZWaveDotNet.SerialAPI;
 
@@ -42,7 +44,7 @@ public class EndPoint
         /// <param name="id"></param>
         /// <param name="node"></param>
         /// <param name="commandClasses"></param>
-        public EndPoint(byte id, Node node, CommandClass[]? commandClasses = null)
+        public EndPoint(byte id, Node node, CommandClass[] commandClasses)
         {
             ID = id;
             this.node = node;
@@ -54,10 +56,43 @@ public EndPoint(byte id, Node node, CommandClass[]? commandClasses = null)
             AddCommandClass(CommandClass.NoOperation);
         }
 
+        /// <summary>
+        /// Deserialize End Point
+        /// </summary>
+        /// <param name="ep"></param>
+        /// <param name="node"></param>
+        public EndPoint(EndPointJson ep, Node node)
+        {
+            ID = ep.ID;
+            this.node = node;
+            foreach (CommandClassJson cc in ep.CommandClasses)
+                AddCommandClass(cc.CommandClass, cc.Secure, cc.Version);
+        }
+
+        internal EndPointJson Serialize()
+        {
+            EndPointJson json = new EndPointJson()
+            {
+                ID = ID,
+                CommandClasses = new CommandClassJson[commandClasses.Count]
+            };
+            for (int i = 0; i < commandClasses.Count; i++)
+            {
+                CommandClass cls = commandClasses.ElementAt(i).Key;
+                json.CommandClasses[i] = new CommandClassJson
+                {
+                    CommandClass = cls,
+                    Version = commandClasses[cls].Version,
+                    Secure = commandClasses[cls].Secure
+                };
+            }
+            return json;
+        }
+
         internal async Task<SupervisionStatus> HandleReport(ReportMessage msg)
         {
-            if (!CommandClasses.ContainsKey(msg.CommandClass))
-                AddCommandClass(msg.CommandClass);
+            if (!HasCommandClass(msg.CommandClass))
+                AddCommandClass(msg.CommandClass, (msg.SecurityLevel != SecurityKey.None));
             return await CommandClasses[msg.CommandClass].ProcessMessage(msg);
         }
 
@@ -98,10 +133,10 @@ public bool HasCommandClass(CommandClass commandClass)
             return null;
         }
 
-        private void AddCommandClass(CommandClass cls, bool secure = false)
+        private void AddCommandClass(CommandClass cls, bool secure = false, byte version = 1)
         {
-            if (!this.commandClasses.ContainsKey(cls))
-                this.commandClasses.Add(cls, CommandClassBase.Create(cls, node, ID, secure, 1)); //TODO
+            if (!HasCommandClass(cls))
+                this.commandClasses.Add(cls, CommandClassBase.Create(cls, node, ID, secure, version));
         }
 
         /// 

ZWaveDotNet/Entities/JSON/EndPointJSON.cs

@@ -0,0 +1,24 @@
+// ZWaveDotNet Copyright (C) 2024 
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or any later version.
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY, without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+// See the GNU Affero General Public License for more details.
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+namespace ZWaveDotNet.Entities.JSON
+{
+    #pragma warning disable CS1591
+    public class EndPointJson
+    {
+        #pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+        public byte ID { get; set; }
+        public CommandClassJson[] CommandClasses { get; set; }
+        #pragma warning restore CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+    }
+    #pragma warning restore CS1591
+}

ZWaveDotNet/Entities/JSON/NodeJSON.cs

@@ -24,6 +24,7 @@ public class NodeJSON
         public ushort ID { get; set; }
         public CommandClassJson[] CommandClasses { get; set; }
         public SecurityKey[] GrantedKeys { get; set; }
+        public EndPointJson[] EndPoints { get; set; }
         #pragma warning restore CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
     }
     #pragma warning restore CS1591

ZWaveDotNet/Entities/Node.cs

@@ -178,7 +178,8 @@ public byte EndPointCount
         /// <returns></returns>
         public EndPoint? GetEndPoint(byte ID)
         {
-            if (ID >= endPoints.Count)
+            ID--;
+            if (ID >= endPoints.Count || ID < 0)
                 return null;
             return endPoints[ID];
         }
@@ -258,15 +259,15 @@ private async Task<SupervisionStatus> HandleReport(ReportMessage msg)
         {
             if (msg.SourceEndpoint == 0)
             {
-                if (!commandClasses.ContainsKey(msg.CommandClass))
+                if (!HasCommandClass(msg.CommandClass))
                     AddCommandClass(msg.CommandClass, (msg.SecurityLevel != SecurityKey.None));
                 return await commandClasses[msg.CommandClass].ProcessMessage(msg);
             }
             else
             {
                 EndPoint? ep = GetEndPoint(msg.SourceEndpoint);
                 if (ep != null)
-                    return await ep.HandleReport(msg).ConfigureAwait(false);
+                    return await ep.HandleReport(msg);
             }
             return SupervisionStatus.NoSupport;
         }
@@ -317,7 +318,8 @@ internal NodeJSON Serialize()
                 NodeProtocolInfo = nodeInfo,
                 ID = ID,
                 CommandClasses = new CommandClassJson[commandClasses.Count],
-                Interviewed = Interviewed
+                Interviewed = Interviewed,
+                EndPoints = new EndPointJson[endPoints.Count]
             };
             if (controller.SecurityManager != null)
             {
@@ -334,11 +336,13 @@ internal NodeJSON Serialize()
                 CommandClass cls = commandClasses.ElementAt(i).Key;
                 json.CommandClasses[i] = new CommandClassJson
                 {
-                    CommandClass = commandClasses[cls].CommandClass,
+                    CommandClass = cls,
                     Version = commandClasses[cls].Version,
                     Secure = commandClasses[cls].Secure
                 };
             }
+            for (int i = 0; i < endPoints.Count; i++)
+                json.EndPoints[i] = endPoints[i].Serialize();
             return json;
         }
 
@@ -348,6 +352,9 @@ internal void Deserialize(NodeJSON json)
             foreach (CommandClassJson cc in json.CommandClasses)
                 AddCommandClass(cc.CommandClass, cc.Secure, cc.Version);
 
+            foreach (EndPointJson ep in json.EndPoints)
+                endPoints.Add(new EndPoint(ep, this));
+
             if (controller.SecurityManager != null)
             {
                 foreach (SecurityKey grantedKey in json.GrantedKeys)
@@ -394,7 +401,7 @@ private async Task Interview(bool newlyIncluded, SecurityManager.NetworkKey? key
                 if (!newlyIncluded && key == null)
                 {
                     //We need to try keys one at a time
-                    if (commandClasses.ContainsKey(CommandClass.Security0))
+                    if (HasCommandClass(CommandClass.Security0))
                     {
                         controller.SecurityManager.GrantKey(ID, SecurityManager.RecordType.S0);
                         Log.Information("Checking S0 Security");
@@ -426,7 +433,7 @@ private async Task Interview(bool newlyIncluded, SecurityManager.NetworkKey? key
                             controller.SecurityManager.RevokeKey(ID, SecurityManager.RecordType.S0);
                         }
                     }
-                    if (commandClasses.ContainsKey(CommandClass.Security2))
+                    if (HasCommandClass(CommandClass.Security2))
                     {
                         controller.SecurityManager.GrantKey(ID, SecurityManager.RecordType.S2UnAuth, controller.NetworkKeyS2UnAuth);
                         Log.Information("Checking S2 Unauth Security");
@@ -525,22 +532,25 @@ private async Task Interview(bool newlyIncluded, SecurityManager.NetworkKey? key
                 else
                 {
                     //Whatever keys we have is what the device has
-                    if (key != null && key.Key == SecurityManager.RecordType.S0 && commandClasses.ContainsKey(CommandClass.Security0))
+                    if (key != null && key.Key == SecurityManager.RecordType.S0 && HasCommandClass(CommandClass.Security0))
                         await RequestS0(cancellationToken).ConfigureAwait(false);
-                    else if (key != null && commandClasses.ContainsKey(CommandClass.Security2))
+                    else if (key != null && HasCommandClass(CommandClass.Security2))
                         await RequestS2(cancellationToken).ConfigureAwait(false);
                 }
             }
-            if (this.commandClasses.ContainsKey(CommandClass.MultiChannel))
+            if (HasCommandClass(CommandClass.MultiChannel))
             {
                 Log.Information("Requesting MultiChannel EndPoints");
-                EndPointReport epReport = await ((MultiChannel)commandClasses[CommandClass.MultiChannel]).GetEndPoints(cancellationToken);
+                EndPointReport epReport = await GetCommandClass<MultiChannel>()!.GetEndPoints(cancellationToken);
                 for (int i = 0; i < epReport.IndividualEndPoints; i++)
-                    endPoints.Add(new EndPoint((byte)(i + 1), this));
+                {
+                    EndPointCapabilities caps = await GetCommandClass<MultiChannel>()!.GetCapabilities((byte)(i + 1), cancellationToken);
+                    endPoints.Add(new EndPoint((byte)(i + 1), this, caps.CommandClasses));
+                }
             }
 
             Log.Information("Checking Command Class Versions");
-            if (this.commandClasses.ContainsKey(CommandClass.Version))
+            if (HasCommandClass(CommandClass.Version))
             {
                 CommandClasses.Version version = (CommandClasses.Version)commandClasses[CommandClass.Version];
                 foreach (CommandClassBase cc in commandClasses.Values)
@@ -557,6 +567,11 @@ private async Task Interview(bool newlyIncluded, SecurityManager.NetworkKey? key
                                 try
                                 {
                                     cc.Version = await version.GetCommandClassVersion(cc.CommandClass, cts.Token);
+                                    foreach (EndPoint ep in endPoints)
+                                    {
+                                        if (HasCommandClass(cc.CommandClass))
+                                            ep.CommandClasses[cc.CommandClass].Version = cc.Version;
+                                    }
                                 }
                                 catch (OperationCanceledException oc)
                                 {