pepperdash/EssentialsPluginTemplate
1
0
Fork 0
mirror of https://github.com/PepperDash/EssentialsPluginTemplate.git synced 2026-01-11 19:44:38 +00:00
Code Issues Packages Projects Releases Wiki Activity

feat: update for Essentials 2 & remove deprecation warnings

Browse Source 
BREAKING CHANGE: Drop 3-series support
This commit is contained in:
Andrew Welker
2025-07-29 13:11:00 -05:00
parent ba5d0f33a6
commit cf3f35a53c
14 changed files with 496 additions and 451 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
.editorconfig Normal file
View File

@@ -0,0 +1,20 @@
root=true
[*.cs]
indent_style=space
indent_size=2
# .editorconfig
# Define a naming style for camelCase without an underscore prefix
dotnet_naming_style.private_field_camel_case.capitalization = camel_case
dotnet_naming_style.private_field_camel_case.required_prefix =
# Define a naming rule for private fields to use the defined style
dotnet_naming_rule.private_field_no_underscore.symbols = private_fields
dotnet_naming_rule.private_field_no_underscore.style = private_field_camel_case
dotnet_naming_rule.private_field_no_underscore.severity = warning
# Define the symbol kind for private fields
dotnet_naming_symbols.private_fields.applicable_kinds = field
dotnet_naming_symbols.private_fields.applicable_accessibilities = private

9
.vscode/extensions.json vendored Normal file
View File

@@ -0,0 +1,9 @@
{
"recommendations": [
"ms-dotnettools.vscode-dotnet-runtime",
"ms-dotnettools.csharp",
"ms-dotnettools.csdevkit",
"vivaxy.vscode-conventional-commits",
"mhutchie.git-graph"
]
}

32
.vscode/settings.json vendored Normal file
View File

@@ -0,0 +1,32 @@
{
"workbench.colorCustomizations": {
"activityBar.activeBackground": "#8c57e5",
"activityBar.background": "#8c57e5",
"activityBar.foreground": "#e7e7e7",
"activityBar.inactiveForeground": "#e7e7e799",
"activityBarBadge.background": "#6e3411",
"activityBarBadge.foreground": "#e7e7e7",
"commandCenter.border": "#e7e7e799",
"sash.hoverBorder": "#8c57e5",
"statusBar.background": "#6e2bde",
"statusBar.foreground": "#e7e7e7",
"statusBarItem.hoverBackground": "#8c57e5",
"statusBarItem.remoteBackground": "#6e2bde",
"statusBarItem.remoteForeground": "#e7e7e7",
"titleBar.activeBackground": "#6e2bde",
"titleBar.activeForeground": "#e7e7e7",
"titleBar.inactiveBackground": "#6e2bde99",
"titleBar.inactiveForeground": "#e7e7e799"
},
"peacock.color": "#6e2bde",
"[csharp]": {
"editor.defaultFormatter": "ms-dotnettools.csharp",
"editor.formatOnSave": true,
"editor.formatOnSaveMode": "file"
},
"csharp.inlayHints.enableInlayHintsForImplicitObjectCreation": true,
"csharp.inlayHints.enableInlayHintsForImplicitVariableTypes": true,
"csharp.inlayHints.enableInlayHintsForLambdaParameterTypes": true,
"csharp.inlayHints.enableInlayHintsForTypes": true,
"dotnet.formatting.organizeImportsOnFormat": true
}

20
epi-make-model.3Series.sln
View File

@@ -1,20 +0,0 @@
Microsoft Visual Studio Solution File, Format Version 10.00
# Visual Studio 2008
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "epi-make-model.3Series", "src\epi-make-model.3Series.csproj", "{9D249E47-8F95-4437-A6BB-563510287AD1}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU
Release|Any CPU = Release|Any CPU
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{9D249E47-8F95-4437-A6BB-563510287AD1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{9D249E47-8F95-4437-A6BB-563510287AD1}.Debug|Any CPU.Build.0 = Debug|Any CPU
{9D249E47-8F95-4437-A6BB-563510287AD1}.Release|Any CPU.ActiveCfg = Release|Any CPU
{9D249E47-8F95-4437-A6BB-563510287AD1}.Release|Any CPU.Build.0 = Release|Any CPU
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
EndGlobal

3
packages.config
View File

@@ -1,3 +0,0 @@
<packages>
<package id="PepperDashEssentials" version="1.16.1" targetFramework="net35" allowedVersions="[1.0,2.0)"/>
</packages>

20
src/MakeModelConfigObject.cs
View File

@@ -1,7 +1,7 @@
using System.Collections.Generic;
using Newtonsoft.Json;
using PepperDash.Essentials.Core;
using System.Collections.Generic;
using Newtonsoft.Json;
using PepperDash.Essentials.Core;
namespace PepperDash.Essentials.Plugin
{
/// <summary>
@@ -14,7 +14,7 @@ namespace PepperDash.Essentials.Plugin
/// "EssentialsPluginConfigObjectTemplate" renamed to "SamsungMdcConfig"
/// </example>
[ConfigSnippet("\"properties\":{\"control\":{}")]
public class EssentialsPluginTemplateConfigObject
public class MakeModelConfig
{
/// <summary>
/// JSON control object
@@ -27,7 +27,7 @@ namespace PepperDash.Essentials.Plugin
/// <example>
/// <code>
/// "control": {
/// "method": "tcpIp",
/// "method": "tcpIp",
/// "controlPortDevKey": "processor",
/// "controlPortNumber": 1,
/// "comParams": {
@@ -139,7 +139,7 @@ namespace PepperDash.Essentials.Plugin
/// </code>
/// </example>
[JsonProperty("DeviceDictionary")]
public Dictionary<string, EssentialsPluginTemplateConfigObjectDictionary> DeviceDictionary { get; set; }
public Dictionary<string, MakeModelConfigDictionary> DeviceDictionary { get; set; }
/// <summary>
/// Constuctor
@@ -148,9 +148,9 @@ namespace PepperDash.Essentials.Plugin
/// If using a collection you must instantiate the collection in the constructor
/// to avoid exceptions when reading the configuration file
/// </remarks>
public EssentialsPluginTemplateConfigObject()
public MakeModelConfig()
{
DeviceDictionary = new Dictionary<string, EssentialsPluginTemplateConfigObjectDictionary>();
DeviceDictionary = new Dictionary<string, MakeModelConfigDictionary>();
}
}
@@ -172,7 +172,7 @@ namespace PepperDash.Essentials.Plugin
/// }
/// </code>
/// </example>
public class EssentialsPluginTemplateConfigObjectDictionary
public class MakeModelConfigDictionary
{
/// <summary>
/// Serializes collection name property

53
src/MakeModelCrestronDevice.cs
View File

@@ -1,29 +1,29 @@
// For Basic SIMPL# Classes
// For Basic SIMPL#Pro classes
using Crestron.SimplSharpPro;
using Crestron.SimplSharpPro.DeviceSupport;
using PepperDash.Core;
using PepperDash.Essentials.Core;
using PepperDash.Essentials.Core.Bridges;
// For Basic SIMPL#Pro classes
using Crestron.SimplSharpPro;
using Crestron.SimplSharpPro.DeviceSupport;
using PepperDash.Core.Logging;
using PepperDash.Essentials.Core;
using PepperDash.Essentials.Core.Bridges;
namespace PepperDash.Essentials.Plugin
{
/// <summary>
/// Plugin device
/// </summary>
/// <remarks>
/// Rename the class to match the device plugin being developed.
/// </remarks>
/// <example>
/// "EssentialsPluginDeviceTemplate" renamed to "SamsungMdcDevice"
/// </example>
public class EssentialsPluginTemplateCrestronDevice : CrestronGenericBridgeableBaseDevice
/// <summary>
/// Plugin device
/// </summary>
/// <remarks>
/// Rename the class to match the device plugin being developed.
/// </remarks>
/// <example>
/// "EssentialsPluginDeviceTemplate" renamed to "SamsungMdcDevice"
/// </example>
public class MakeModelCrestronDevice : CrestronGenericBridgeableBaseDevice
{
/// <summary>
/// It is often desirable to store the config
/// </summary>
private EssentialsPluginTemplateConfigObject _config;
private readonly MakeModelConfig config;
#region Constructor for Devices without IBasicCommunication. Remove if not needed
@@ -34,16 +34,16 @@ namespace PepperDash.Essentials.Plugin
/// <param name="name"></param>
/// <param name="config"></param>
/// <param name="hardware"></param>
public EssentialsPluginTemplateCrestronDevice(string key, string name, EssentialsPluginTemplateConfigObject config, GenericBase hardware)
public MakeModelCrestronDevice(string key, string name, MakeModelConfig config, GenericBase hardware)
: base(key, name, hardware)
{
Debug.Console(0, this, "Constructing new {0} instance", name);
this.LogInformation("Constructing new {0} instance", name);
// The base class takes care of registering the hardware device for you
// TODO [ ] Update the constructor as needed for the plugin device being developed
_config = config;
this.config = config;
}
#endregion
@@ -63,10 +63,7 @@ namespace PepperDash.Essentials.Plugin
var joinMap = new EssentialsPluginTemplateBridgeJoinMap(joinStart);
// This adds the join map to the collection on the bridge
if (bridge != null)
{
bridge.AddJoinMap(Key, joinMap);
}
bridge?.AddJoinMap(Key, joinMap);
var customJoins = JoinMapHelper.TryGetJoinMapAdvancedForDevice(joinMapKey);
@@ -75,8 +72,8 @@ namespace PepperDash.Essentials.Plugin
joinMap.SetCustomJoinData(customJoins);
}
Debug.Console(1, "Linking to Trilist '{0}'", trilist.ID.ToString("X"));
Debug.Console(0, "Linking to Bridge Type {0}", GetType().Name);
this.LogDebug("Linking to Trilist {id}", trilist.ID.ToString("X"));
this.LogInformation("Linking to Bridge Type {type}", GetType().Name);
// TODO [ ] Implement bridge links as needed

87
src/MakeModelCrestronDeviceFactory.cs Normal file
View File

@@ -0,0 +1,87 @@
using System.Collections.Generic;
using Crestron.SimplSharpPro.UI;
using PepperDash.Core;
using PepperDash.Essentials.Core;
namespace PepperDash.Essentials.Plugin
{
/// <summary>
/// Plugin device factory for Crestron wrapper devices
/// </summary>
/// <remarks>
/// Rename the class to match the device plugin being developed
/// </remarks>
/// <example>
/// "EssentialsPluginFactoryTemplate" renamed to "MyCrestronDeviceFactory"
/// </example>
public class MakeModelCrestronDeviceFactory : EssentialsPluginDeviceFactory<MakeModelCrestronDevice>
{
/// <summary>
/// Plugin device factory constructor
/// </summary>
/// <remarks>
/// Update the MinimumEssentialsFrameworkVersion & TypeNames as needed when creating a plugin
/// </remarks>
/// <example>
/// Set the minimum Essentials Framework Version
/// <code>
/// MinimumEssentialsFrameworkVersion = "1.6.4;
/// </code>
/// In the constructor we initialize the list with the typenames that will build an instance of this device
/// <code>
/// TypeNames = new List<string>() { "SamsungMdc", "SamsungMdcDisplay" };
/// </code>
/// </example>
public MakeModelCrestronDeviceFactory()
{
// Set the minimum Essentials Framework Version
// TODO [ ] Update the Essentials minimum framework version which this plugin has been tested against
MinimumEssentialsFrameworkVersion = "2.12.1";
// In the constructor we initialize the list with the typenames that will build an instance of this device
// TODO [ ] Update the TypeNames for the plugin being developed
TypeNames = new List<string>() { "examplePluginCrestronDevice" };
}
/// <summary>
/// Builds and returns an instance of EssentialsPluginTemplateCrestronDevice
/// </summary>
/// <param name="dc">device configuration</param>
/// <returns>plugin device or null</returns>
/// <remarks>
/// The example provided below takes the device key, name, properties config and the comms device created.
/// Modify the EssetnialsPlugingDeviceTemplate constructor as needed to meet the requirements of the plugin device.
/// </remarks>
/// <seealso cref="PepperDash.Core.eControlMethod"/>
public override EssentialsDevice BuildDevice(PepperDash.Essentials.Core.Config.DeviceConfig dc)
{
Debug.LogDebug("[{key}] Factory Attempting to create new device from type: {type}", dc.Key, dc.Type);
// get the plugin device properties configuration object & check for null
var propertiesConfig = dc.Properties.ToObject<MakeModelConfig>();
if (propertiesConfig == null)
{
Debug.LogWarning("[{key}] Factory: failed to read properties config for {name}", dc.Key, dc.Name);
return null;
}
var controlConfig = CommFactory.GetControlPropertiesConfig(dc);
if (controlConfig == null)
{
var myTouchpanel = new Tsw760(controlConfig.IpIdInt, Global.ControlSystem);
return new MakeModelCrestronDevice(dc.Key, dc.Name, propertiesConfig, myTouchpanel);
}
else
{
Debug.LogWarning("[{key}] Factory: Unable to get control properties from device config for {name}", dc.Key, dc.Name);
return null;
}
}
}
}

248
src/MakeModelDevice.cs
View File

@@ -3,6 +3,7 @@
using Crestron.SimplSharpPro.DeviceSupport;
using PepperDash.Core;
using PepperDash.Core.Logging;
using PepperDash.Essentials.Core;
using PepperDash.Essentials.Core.Bridges;
using PepperDash.Essentials.Core.Queues;
@@ -18,36 +19,36 @@ namespace PepperDash.Essentials.Plugin
/// <example>
/// "EssentialsPluginDeviceTemplate" renamed to "SamsungMdcDevice"
/// </example>
public class EssentialsPluginTemplateDevice : EssentialsBridgeableDevice
{
/// <summary>
/// It is often desirable to store the config
/// </summary>
private EssentialsPluginTemplateConfigObject _config;
public class MakeModelDevice : EssentialsBridgeableDevice
{
/// <summary>
/// It is often desirable to store the config
/// </summary>
private readonly MakeModelConfig config;
/// <summary>
/// Provides a queue and dedicated worker thread for processing feedback messages from a device.
/// </summary>
private GenericQueue ReceiveQueue;
/// <summary>
/// Provides a queue and dedicated worker thread for processing feedback messages from a device.
/// </summary>
private readonly GenericQueue receiveQueue;
#region IBasicCommunication Properties and Constructor. Remove if not needed.
#region IBasicCommunication Properties and Constructor. Remove if not needed.
// TODO [ ] Add, modify, remove properties and fields as needed for the plugin being developed
private readonly IBasicCommunication _comms;
private readonly GenericCommunicationMonitor _commsMonitor;
// TODO [ ] Add, modify, remove properties and fields as needed for the plugin being developed
private readonly IBasicCommunication comms;
private readonly GenericCommunicationMonitor commsMonitor;
// _comms gather for ASCII based API's
// comms gather for ASCII based API's
// TODO [ ] If not using an ASCII based API, delete the properties below
private readonly CommunicationGather _commsGather;
private readonly CommunicationGather commsGather;
/// <summary>
/// Set this value to that of the delimiter used by the API (if applicable)
/// </summary>
private const string CommsDelimiter = "\r";
/// <summary>
/// Set this value to that of the delimiter used by the API (if applicable)
/// </summary>
private const string commsDelimiter = "\r";
// _comms byte buffer for HEX/byte based API's
// comms byte buffer for HEX/byte based API's
// TODO [ ] If not using an HEX/byte based API, delete the properties below
private byte[] _commsByteBuffer = { };
private readonly byte[] commsByteBuffer = { };
@@ -55,22 +56,22 @@ namespace PepperDash.Essentials.Plugin
/// Connects/disconnects the comms of the plugin device
/// </summary>
/// <remarks>
/// triggers the _comms.Connect/Disconnect as well as thee comms monitor start/stop
/// triggers the comms.Connect/Disconnect as well as thee comms monitor start/stop
/// </remarks>
public bool Connect
{
get { return _comms.IsConnected; }
get { return comms.IsConnected; }
set
{
if (value)
{
_comms.Connect();
_commsMonitor.Start();
comms.Connect();
commsMonitor.Start();
}
else
{
_comms.Disconnect();
_commsMonitor.Stop();
comms.Disconnect();
commsMonitor.Stop();
}
}
}
@@ -97,93 +98,91 @@ namespace PepperDash.Essentials.Plugin
/// <param name="name"></param>
/// <param name="config"></param>
/// <param name="comms"></param>
public EssentialsPluginTemplateDevice(string key, string name, EssentialsPluginTemplateConfigObject config, IBasicCommunication comms)
: base(key, name)
public MakeModelDevice(string key, string name, MakeModelConfig config, IBasicCommunication comms)
: base(key, name)
{
Debug.Console(0, this, "Constructing new {0} instance", name);
this.LogInformation("Constructing new {0} instance", name);
// TODO [ ] Update the constructor as needed for the plugin device being developed
_config = config;
this.config = config;
ReceiveQueue = new GenericQueue(key + "-rxqueue"); // If you need to set the thread priority, use one of the available overloaded constructors.
receiveQueue = new GenericQueue(key + "-rxqueue"); // If you need to set the thread priority, use one of the available overloaded constructors.
ConnectFeedback = new BoolFeedback(() => Connect);
OnlineFeedback = new BoolFeedback(() => _commsMonitor.IsOnline);
StatusFeedback = new IntFeedback(() => (int)_commsMonitor.Status);
ConnectFeedback = new BoolFeedback("connect", () => Connect);
OnlineFeedback = new BoolFeedback("online", () => commsMonitor.IsOnline);
StatusFeedback = new IntFeedback("status", () => (int)commsMonitor.Status);
_comms = comms;
_commsMonitor = new GenericCommunicationMonitor(this, _comms, _config.PollTimeMs, _config.WarningTimeoutMs, _config.ErrorTimeoutMs, Poll);
this.comms = comms;
commsMonitor = new GenericCommunicationMonitor(this, this.comms, this.config.PollTimeMs, this.config.WarningTimeoutMs, this.config.ErrorTimeoutMs, Poll);
var socket = _comms as ISocketStatus;
var socket = this.comms as ISocketStatus;
if (socket != null)
{
// device comms is IP **ELSE** device comms is RS232
socket.ConnectionChange += socket_ConnectionChange;
Connect = true;
}
}
#region Communication data event handlers. Comment out any that don't apply to the API type
#region Communication data event handlers. Comment out any that don't apply to the API type
// Only one of the below handlers should be necessary.
// Only one of the below handlers should be necessary.
// _comms gather for any API that has a defined delimiter
// comms gather for any API that has a defined delimiter
// TODO [ ] If not using an ASCII based API, remove the line below
_commsGather = new CommunicationGather(_comms, CommsDelimiter);
_commsGather.LineReceived += Handle_LineRecieved;
commsGather = new CommunicationGather(this.comms, commsDelimiter);
commsGather.LineReceived += Handle_LineRecieved;
// _comms byte buffer for HEX/byte based API's with no delimiter
// TODO [ ] If not using an HEX/byte based API, remove the line below
_comms.BytesReceived += Handle_BytesReceived;
// comms byte buffer for HEX/byte based API's with no delimiter
// TODO [ ] If not using an HEX/byte based API, remove the line below
this.comms.BytesReceived += Handle_BytesReceived;
// _comms byte buffer for HEX/byte based API's with no delimiter
// TODO [ ] If not using an HEX/byte based API, remove the line below
_comms.TextReceived += Handle_TextReceived;
// comms byte buffer for HEX/byte based API's with no delimiter
// TODO [ ] If not using an HEX/byte based API, remove the line below
this.comms.TextReceived += Handle_TextReceived;
#endregion
}
#endregion
}
private void socket_ConnectionChange(object sender, GenericSocketStatusChageEventArgs args)
{
if (ConnectFeedback != null)
ConnectFeedback.FireUpdate();
ConnectFeedback?.FireUpdate();
if (StatusFeedback != null)
StatusFeedback.FireUpdate();
StatusFeedback?.FireUpdate();
}
// TODO [ ] If not using an API with a delimeter, delete the method below
private void Handle_LineRecieved(object sender, GenericCommMethodReceiveTextArgs args)
{
// TODO [ ] Implement method
// Enqueues the message to be processed in a dedicated thread, but the specified method
ReceiveQueue.Enqueue(new ProcessStringMessage(args.Text, ProcessFeedbackMessage));
// Enqueues the message to be processed in a dedicated thread, but the specified method
receiveQueue.Enqueue(new ProcessStringMessage(args.Text, ProcessFeedbackMessage));
}
// TODO [ ] If not using an HEX/byte based API with no delimeter, delete the method below
// TODO [ ] If not using an HEX/byte based API with no delimeter, delete the method below
private void Handle_BytesReceived(object sender, GenericCommMethodReceiveBytesArgs args)
{
// TODO [ ] Implement method
throw new System.NotImplementedException();
}
// TODO [ ] If not using an ASCII based API with no delimeter, delete the method below
void Handle_TextReceived(object sender, GenericCommMethodReceiveTextArgs e)
{
// TODO [ ] Implement method
throw new System.NotImplementedException();
}
// TODO [ ] If not using an ASCII based API with no delimeter, delete the method below
void Handle_TextReceived(object sender, GenericCommMethodReceiveTextArgs e)
{
// TODO [ ] Implement method
throw new System.NotImplementedException();
}
/// <summary>
/// This method should perform any necessary parsing of feedback messages from the device
/// </summary>
/// <param name="message"></param>
void ProcessFeedbackMessage(string message)
{
/// <summary>
/// This method should perform any necessary parsing of feedback messages from the device
/// </summary>
/// <param name="message"></param>
void ProcessFeedbackMessage(string message)
{
}
}
// TODO [ ] If not using an ACII based API, delete the properties below
@@ -198,7 +197,7 @@ namespace PepperDash.Essentials.Plugin
{
if (string.IsNullOrEmpty(text)) return;
_comms.SendText(string.Format("{0}{1}", text, CommsDelimiter));
comms.SendText(string.Format("{0}{1}", text, commsDelimiter));
}
// TODO [ ] If not using an HEX/byte based API, delete the properties below
@@ -213,7 +212,7 @@ namespace PepperDash.Essentials.Plugin
{
if (bytes == null) return;
_comms.SendBytes(bytes);
comms.SendBytes(bytes);
}
/// <summary>
@@ -225,74 +224,71 @@ namespace PepperDash.Essentials.Plugin
public void Poll()
{
// TODO [ ] Update Poll method as needed for the plugin being developed
// Example: SendText("getstatus");
// Example: SendText("getstatus");
throw new System.NotImplementedException();
}
}
#endregion
#endregion
#region Overrides of EssentialsBridgeableDevice
#region Overrides of EssentialsBridgeableDevice
/// <summary>
/// Links the plugin device to the EISC bridge
/// </summary>
/// <param name="trilist"></param>
/// <param name="joinStart"></param>
/// <param name="joinMapKey"></param>
/// <param name="bridge"></param>
public override void LinkToApi(BasicTriList trilist, uint joinStart, string joinMapKey, EiscApiAdvanced bridge)
{
var joinMap = new EssentialsPluginTemplateBridgeJoinMap(joinStart);
/// <summary>
/// Links the plugin device to the EISC bridge
/// </summary>
/// <param name="trilist"></param>
/// <param name="joinStart"></param>
/// <param name="joinMapKey"></param>
/// <param name="bridge"></param>
public override void LinkToApi(BasicTriList trilist, uint joinStart, string joinMapKey, EiscApiAdvanced bridge)
{
var joinMap = new EssentialsPluginTemplateBridgeJoinMap(joinStart);
// This adds the join map to the collection on the bridge
if (bridge != null)
{
bridge.AddJoinMap(Key, joinMap);
}
// This adds the join map to the collection on the bridge
bridge?.AddJoinMap(Key, joinMap);
var customJoins = JoinMapHelper.TryGetJoinMapAdvancedForDevice(joinMapKey);
var customJoins = JoinMapHelper.TryGetJoinMapAdvancedForDevice(joinMapKey);
if (customJoins != null)
{
joinMap.SetCustomJoinData(customJoins);
}
if (customJoins != null)
{
joinMap.SetCustomJoinData(customJoins);
}
Debug.Console(1, "Linking to Trilist '{0}'", trilist.ID.ToString("X"));
Debug.Console(0, "Linking to Bridge Type {0}", GetType().Name);
this.LogDebug("Linking to Trilist {id}", trilist.ID.ToString("X"));
this.LogInformation("Linking to Bridge Type {type}", GetType().Name);
// TODO [ ] Implement bridge links as needed
// TODO [ ] Implement bridge links as needed
// links to bridge
trilist.SetString(joinMap.DeviceName.JoinNumber, Name);
// links to bridge
trilist.SetString(joinMap.DeviceName.JoinNumber, Name);
trilist.SetBoolSigAction(joinMap.Connect.JoinNumber, sig => Connect = sig);
ConnectFeedback.LinkInputSig(trilist.BooleanInput[joinMap.Connect.JoinNumber]);
trilist.SetBoolSigAction(joinMap.Connect.JoinNumber, sig => Connect = sig);
ConnectFeedback.LinkInputSig(trilist.BooleanInput[joinMap.Connect.JoinNumber]);
StatusFeedback.LinkInputSig(trilist.UShortInput[joinMap.Status.JoinNumber]);
OnlineFeedback.LinkInputSig(trilist.BooleanInput[joinMap.IsOnline.JoinNumber]);
StatusFeedback.LinkInputSig(trilist.UShortInput[joinMap.Status.JoinNumber]);
OnlineFeedback.LinkInputSig(trilist.BooleanInput[joinMap.IsOnline.JoinNumber]);
UpdateFeedbacks();
UpdateFeedbacks();
trilist.OnlineStatusChange += (o, a) =>
{
if (!a.DeviceOnLine) return;
trilist.OnlineStatusChange += (o, a) =>
{
if (!a.DeviceOnLine) return;
trilist.SetString(joinMap.DeviceName.JoinNumber, Name);
UpdateFeedbacks();
};
}
trilist.SetString(joinMap.DeviceName.JoinNumber, Name);
UpdateFeedbacks();
};
}
private void UpdateFeedbacks()
{
// TODO [ ] Update as needed for the plugin being developed
ConnectFeedback.FireUpdate();
OnlineFeedback.FireUpdate();
StatusFeedback.FireUpdate();
}
private void UpdateFeedbacks()
{
// TODO [ ] Update as needed for the plugin being developed
ConnectFeedback.FireUpdate();
OnlineFeedback.FireUpdate();
StatusFeedback.FireUpdate();
}
#endregion
#endregion
}
}
}

85
src/MakeModelDeviceFactory.cs Normal file
View File

@@ -0,0 +1,85 @@
using System.Collections.Generic;
using PepperDash.Core;
using PepperDash.Essentials.Core;
namespace PepperDash.Essentials.Plugin
{
/// <summary>
/// Plugin device factory for devices that use IBasicCommunication
/// </summary>
/// <remarks>
/// Rename the class to match the device plugin being developed
/// </remarks>
/// <example>
/// "EssentialsPluginFactoryTemplate" renamed to "MyDeviceFactory"
/// </example>
public class MakeModelDeviceFactory : EssentialsPluginDeviceFactory<MakeModelDevice>
{
/// <summary>
/// Plugin device factory constructor
/// </summary>
/// <remarks>
/// Update the MinimumEssentialsFrameworkVersion & TypeNames as needed when creating a plugin
/// </remarks>
/// <example>
/// Set the minimum Essentials Framework Version
/// <code>
/// MinimumEssentialsFrameworkVersion = "2.12.1;
/// </code>
/// In the constructor we initialize the list with the typenames that will build an instance of this device
/// <code>
/// TypeNames = new List<string>() { "SamsungMdc", "SamsungMdcDisplay" };
/// </code>
/// </example>
public MakeModelDeviceFactory()
{
// Set the minimum Essentials Framework Version
// TODO [ ] Update the Essentials minimum framework version which this plugin has been tested against
MinimumEssentialsFrameworkVersion = "2.12.1";
// In the constructor we initialize the list with the typenames that will build an instance of this device
// TODO [ ] Update the TypeNames for the plugin being developed
TypeNames = new List<string>() { "examplePluginDevice" };
}
/// <summary>
/// Builds and returns an instance of EssentialsPluginDeviceTemplate
/// </summary>
/// <param name="dc">device configuration</param>
/// <returns>plugin device or null</returns>
/// <remarks>
/// The example provided below takes the device key, name, properties config and the comms device created.
/// Modify the EssetnialsPlugingDeviceTemplate constructor as needed to meet the requirements of the plugin device.
/// </remarks>
/// <seealso cref="PepperDash.Core.eControlMethod"/>
public override EssentialsDevice BuildDevice(PepperDash.Essentials.Core.Config.DeviceConfig dc)
{
Debug.LogVerbose("[{key}] Factory Attempting to create new device from type: {type}", dc.Key, dc.Type);
// get the plugin device properties configuration object & check for null
var propertiesConfig = dc.Properties.ToObject<MakeModelConfig>();
if (propertiesConfig == null)
{
Debug.LogError("[{key}] Factory: failed to read properties config for {name}", dc.Key, dc.Name);
return null;
}
// attempt build the plugin device comms device & check for null
// TODO { ] As of PepperDash Core 1.0.41, HTTP and HTTPS are not valid eControlMethods and will throw an exception.
var comms = CommFactory.CreateCommForDevice(dc);
if (comms == null)
{
Debug.LogError("[{key}] Factory Notice: No control object present for device {name}", dc.Key, dc.Name);
return null;
}
else
{
return new MakeModelDevice(dc.Key, dc.Name, propertiesConfig, comms);
}
}
}
}

239
src/MakeModelFactory.cs
View File

@@ -1,239 +0,0 @@
using System.Collections.Generic;
using Crestron.SimplSharpPro.UI;
using PepperDash.Core;
using PepperDash.Essentials.Core;
namespace PepperDash.Essentials.Plugin
{
/// <summary>
/// Plugin device factory for devices that use IBasicCommunication
/// </summary>
/// <remarks>
/// Rename the class to match the device plugin being developed
/// </remarks>
/// <example>
/// "EssentialsPluginFactoryTemplate" renamed to "MyDeviceFactory"
/// </example>
public class EssentialsPluginTemplateFactory : EssentialsPluginDeviceFactory<EssentialsPluginTemplateDevice>
{
/// <summary>
/// Plugin device factory constructor
/// </summary>
/// <remarks>
/// Update the MinimumEssentialsFrameworkVersion & TypeNames as needed when creating a plugin
/// </remarks>
/// <example>
/// Set the minimum Essentials Framework Version
/// <code>
/// MinimumEssentialsFrameworkVersion = "1.6.4;
/// </code>
/// In the constructor we initialize the list with the typenames that will build an instance of this device
/// <code>
/// TypeNames = new List<string>() { "SamsungMdc", "SamsungMdcDisplay" };
/// </code>
/// </example>
public EssentialsPluginTemplateFactory()
{
// Set the minimum Essentials Framework Version
// TODO [ ] Update the Essentials minimum framework version which this plugin has been tested against
MinimumEssentialsFrameworkVersion = "1.6.4";
// In the constructor we initialize the list with the typenames that will build an instance of this device
// TODO [ ] Update the TypeNames for the plugin being developed
TypeNames = new List<string>() { "examplePluginDevice" };
}
/// <summary>
/// Builds and returns an instance of EssentialsPluginDeviceTemplate
/// </summary>
/// <param name="dc">device configuration</param>
/// <returns>plugin device or null</returns>
/// <remarks>
/// The example provided below takes the device key, name, properties config and the comms device created.
/// Modify the EssetnialsPlugingDeviceTemplate constructor as needed to meet the requirements of the plugin device.
/// </remarks>
/// <seealso cref="PepperDash.Core.eControlMethod"/>
public override EssentialsDevice BuildDevice(PepperDash.Essentials.Core.Config.DeviceConfig dc)
{
Debug.Console(1, "[{0}] Factory Attempting to create new device from type: {1}", dc.Key, dc.Type);
// get the plugin device properties configuration object & check for null
var propertiesConfig = dc.Properties.ToObject<EssentialsPluginTemplateConfigObject>();
if (propertiesConfig == null)
{
Debug.Console(0, "[{0}] Factory: failed to read properties config for {1}", dc.Key, dc.Name);
return null;
}
// attempt build the plugin device comms device & check for null
// TODO { ] As of PepperDash Core 1.0.41, HTTP and HTTPS are not valid eControlMethods and will throw an exception.
var comms = CommFactory.CreateCommForDevice(dc);
if (comms == null)
{
Debug.Console(1, "[{0}] Factory Notice: No control object present for device {1}", dc.Key, dc.Name);
return null;
}
else
{
return new EssentialsPluginTemplateDevice(dc.Key, dc.Name, propertiesConfig, comms);
}
}
}
/// <summary>
/// Plugin device factory for logic devices that don't communicate
/// </summary>
/// <remarks>
/// Rename the class to match the device plugin being developed
/// </remarks>
/// <example>
/// "EssentialsPluginFactoryTemplate" renamed to "MyLogicDeviceFactory"
/// </example>
public class EssentialsPluginTemplateFactoryLogicDevice : EssentialsPluginDeviceFactory<EssentialsPluginTemplateLogicDevice>
{
/// <summary>
/// Plugin device factory constructor
/// </summary>
/// <remarks>
/// Update the MinimumEssentialsFrameworkVersion & TypeNames as needed when creating a plugin
/// </remarks>
/// <example>
/// Set the minimum Essentials Framework Version
/// <code>
/// MinimumEssentialsFrameworkVersion = "1.6.4;
/// </code>
/// In the constructor we initialize the list with the typenames that will build an instance of this device
/// <code>
/// TypeNames = new List<string>() { "SamsungMdc", "SamsungMdcDisplay" };
/// </code>
/// </example>
public EssentialsPluginTemplateFactoryLogicDevice()
{
// Set the minimum Essentials Framework Version
// TODO [ ] Update the Essentials minimum framework version which this plugin has been tested against
MinimumEssentialsFrameworkVersion = "1.6.4";
// In the constructor we initialize the list with the typenames that will build an instance of this device
// TODO [ ] Update the TypeNames for the plugin being developed
TypeNames = new List<string>() { "examplePluginLogicDevice" };
}
/// <summary>
/// Builds and returns an instance of EssentialsPluginTemplateLogicDevice
/// </summary>
/// <param name="dc">device configuration</param>
/// <returns>plugin device or null</returns>
/// <remarks>
/// The example provided below takes the device key, name, properties config and the comms device created.
/// Modify the EssetnialsPlugingDeviceTemplate constructor as needed to meet the requirements of the plugin device.
/// </remarks>
/// <seealso cref="PepperDash.Core.eControlMethod"/>
public override EssentialsDevice BuildDevice(PepperDash.Essentials.Core.Config.DeviceConfig dc)
{
Debug.Console(1, "[{0}] Factory Attempting to create new device from type: {1}", dc.Key, dc.Type);
// get the plugin device properties configuration object & check for null
var propertiesConfig = dc.Properties.ToObject<EssentialsPluginTemplateConfigObject>();
if (propertiesConfig == null)
{
Debug.Console(0, "[{0}] Factory: failed to read properties config for {1}", dc.Key, dc.Name);
return null;
}
var controlConfig = CommFactory.GetControlPropertiesConfig(dc);
if (controlConfig == null)
{
return new EssentialsPluginTemplateLogicDevice(dc.Key, dc.Name, propertiesConfig);
}
else
{
Debug.Console(0, "[{0}] Factory: Unable to get control properties from device config for {1}", dc.Key, dc.Name);
return null;
}
}
}
/// <summary>
/// Plugin device factory for Crestron wrapper devices
/// </summary>
/// <remarks>
/// Rename the class to match the device plugin being developed
/// </remarks>
/// <example>
/// "EssentialsPluginFactoryTemplate" renamed to "MyCrestronDeviceFactory"
/// </example>
public class EssentialsPluginTemplateFactoryCrestronDevice : EssentialsPluginDeviceFactory<EssentialsPluginTemplateCrestronDevice>
{
/// <summary>
/// Plugin device factory constructor
/// </summary>
/// <remarks>
/// Update the MinimumEssentialsFrameworkVersion & TypeNames as needed when creating a plugin
/// </remarks>
/// <example>
/// Set the minimum Essentials Framework Version
/// <code>
/// MinimumEssentialsFrameworkVersion = "1.6.4;
/// </code>
/// In the constructor we initialize the list with the typenames that will build an instance of this device
/// <code>
/// TypeNames = new List<string>() { "SamsungMdc", "SamsungMdcDisplay" };
/// </code>
/// </example>
public EssentialsPluginTemplateFactoryCrestronDevice()
{
// Set the minimum Essentials Framework Version
// TODO [ ] Update the Essentials minimum framework version which this plugin has been tested against
MinimumEssentialsFrameworkVersion = "1.7.5";
// In the constructor we initialize the list with the typenames that will build an instance of this device
// TODO [ ] Update the TypeNames for the plugin being developed
TypeNames = new List<string>() { "examplePluginCrestronDevice" };
}
/// <summary>
/// Builds and returns an instance of EssentialsPluginTemplateCrestronDevice
/// </summary>
/// <param name="dc">device configuration</param>
/// <returns>plugin device or null</returns>
/// <remarks>
/// The example provided below takes the device key, name, properties config and the comms device created.
/// Modify the EssetnialsPlugingDeviceTemplate constructor as needed to meet the requirements of the plugin device.
/// </remarks>
/// <seealso cref="PepperDash.Core.eControlMethod"/>
public override EssentialsDevice BuildDevice(PepperDash.Essentials.Core.Config.DeviceConfig dc)
{
Debug.Console(1, "[{0}] Factory Attempting to create new device from type: {1}", dc.Key, dc.Type);
// get the plugin device properties configuration object & check for null
var propertiesConfig = dc.Properties.ToObject<EssentialsPluginTemplateConfigObject>();
if (propertiesConfig == null)
{
Debug.Console(0, "[{0}] Factory: failed to read properties config for {1}", dc.Key, dc.Name);
return null;
}
var controlConfig = CommFactory.GetControlPropertiesConfig(dc);
if (controlConfig == null)
{
var myTouchpanel = new Tsw760(controlConfig.IpIdInt, Global.ControlSystem);
return new EssentialsPluginTemplateCrestronDevice(dc.Key, dc.Name, propertiesConfig, myTouchpanel);
}
else
{
Debug.Console(0, "[{0}] Factory: Unable to get control properties from device config for {1}", dc.Key, dc.Name);
return null;
}
}
}
}

46
src/MakeModelLogicDevice.cs
View File

@@ -1,25 +1,26 @@
using Crestron.SimplSharpPro.DeviceSupport;
using PepperDash.Core;
using PepperDash.Essentials.Core;
using PepperDash.Essentials.Core.Bridges;
using Crestron.SimplSharpPro.DeviceSupport;
using PepperDash.Core;
using PepperDash.Core.Logging;
using PepperDash.Essentials.Core;
using PepperDash.Essentials.Core.Bridges;
namespace PepperDash.Essentials.Plugin
{
/// <summary>
/// Plugin device template for logic devices that don't communicate outside the program
/// </summary>
/// <remarks>
/// Rename the class to match the device plugin being developed.
/// </remarks>
/// <example>
/// <summary>
/// Plugin device template for logic devices that don't communicate outside the program
/// </summary>
/// <remarks>
/// Rename the class to match the device plugin being developed.
/// </remarks>
/// <example>
/// "EssentialsPluginTemplateLogicDevice" renamed to "SamsungMdcDevice"
/// </example>
public class EssentialsPluginTemplateLogicDevice : EssentialsBridgeableDevice
/// </example>
public class MakeModelLogicDevice : EssentialsBridgeableDevice
{
/// <summary>
/// It is often desirable to store the config
/// </summary>
private EssentialsPluginTemplateConfigObject _config;
private readonly MakeModelConfig config;
/// <summary>
/// Plugin device constructor
@@ -27,14 +28,14 @@ namespace PepperDash.Essentials.Plugin
/// <param name="key"></param>
/// <param name="name"></param>
/// <param name="config"></param>
public EssentialsPluginTemplateLogicDevice(string key, string name, EssentialsPluginTemplateConfigObject config)
public MakeModelLogicDevice(string key, string name, MakeModelConfig config)
: base(key, name)
{
Debug.Console(0, this, "Constructing new {0} instance", name);
this.LogInformation("Constructing new {0} instance", name);
// TODO [ ] Update the constructor as needed for the plugin device being developed
_config = config;
this.config = config;
}
#region Overrides of EssentialsBridgeableDevice
@@ -51,10 +52,7 @@ namespace PepperDash.Essentials.Plugin
var joinMap = new EssentialsPluginTemplateBridgeJoinMap(joinStart);
// This adds the join map to the collection on the bridge
if (bridge != null)
{
bridge.AddJoinMap(Key, joinMap);
}
bridge?.AddJoinMap(Key, joinMap);
var customJoins = JoinMapHelper.TryGetJoinMapAdvancedForDevice(joinMapKey);
@@ -63,8 +61,8 @@ namespace PepperDash.Essentials.Plugin
joinMap.SetCustomJoinData(customJoins);
}
Debug.Console(1, "Linking to Trilist '{0}'", trilist.ID.ToString("X"));
Debug.Console(0, "Linking to Bridge Type {0}", GetType().Name);
this.LogDebug("Linking to Trilist {id}", trilist.ID.ToString("X"));
this.LogInformation("Linking to Bridge Type {type}", GetType().Name);
// TODO [ ] Implement bridge links as needed

83
src/MakeModelLogicDeviceFactory.cs Normal file
View File

@@ -0,0 +1,83 @@
using System.Collections.Generic;
using PepperDash.Core;
using PepperDash.Essentials.Core;
namespace PepperDash.Essentials.Plugin
{
/// <summary>
/// Plugin device factory for logic devices that don't communicate
/// </summary>
/// <remarks>
/// Rename the class to match the device plugin being developed
/// </remarks>
/// <example>
/// "EssentialsPluginFactoryTemplate" renamed to "MyLogicDeviceFactory"
/// </example>
public class MakeModelLogicDeviceFactory : EssentialsPluginDeviceFactory<MakeModelLogicDevice>
{
/// <summary>
/// Plugin device factory constructor
/// </summary>
/// <remarks>
/// Update the MinimumEssentialsFrameworkVersion & TypeNames as needed when creating a plugin
/// </remarks>
/// <example>
/// Set the minimum Essentials Framework Version
/// <code>
/// MinimumEssentialsFrameworkVersion = "1.6.4;
/// </code>
/// In the constructor we initialize the list with the typenames that will build an instance of this device
/// <code>
/// TypeNames = new List<string>() { "SamsungMdc", "SamsungMdcDisplay" };
/// </code>
/// </example>
public MakeModelLogicDeviceFactory()
{
// Set the minimum Essentials Framework Version
// TODO [ ] Update the Essentials minimum framework version which this plugin has been tested against
MinimumEssentialsFrameworkVersion = "2.12.1";
// In the constructor we initialize the list with the typenames that will build an instance of this device
// TODO [ ] Update the TypeNames for the plugin being developed
TypeNames = new List<string>() { "examplePluginLogicDevice" };
}
/// <summary>
/// Builds and returns an instance of EssentialsPluginTemplateLogicDevice
/// </summary>
/// <param name="dc">device configuration</param>
/// <returns>plugin device or null</returns>
/// <remarks>
/// The example provided below takes the device key, name, properties config and the comms device created.
/// Modify the EssetnialsPlugingDeviceTemplate constructor as needed to meet the requirements of the plugin device.
/// </remarks>
/// <seealso cref="PepperDash.Core.eControlMethod"/>
public override EssentialsDevice BuildDevice(PepperDash.Essentials.Core.Config.DeviceConfig dc)
{
Debug.LogDebug("[{key}] Factory Attempting to create new device from type: {type}", dc.Key, dc.Type);
// get the plugin device properties configuration object & check for null
var propertiesConfig = dc.Properties.ToObject<MakeModelConfig>();
if (propertiesConfig == null)
{
Debug.LogError("[{key}] Factory: failed to read properties config for {name}", dc.Key, dc.Name);
return null;
}
var controlConfig = CommFactory.GetControlPropertiesConfig(dc);
if (controlConfig == null)
{
return new MakeModelLogicDevice(dc.Key, dc.Name, propertiesConfig);
}
else
{
Debug.LogError("[{key}] Factory: Unable to get control properties from device config for {name}", dc.Key, dc.Name);
return null;
}
}
}
}

2
src/epi-make-model.4Series.csproj
View File

@@ -35,7 +35,7 @@
</ItemGroup>
<ItemGroup>
<PackageReference Include="PepperDashEssentials" Version="2.0.0" >
<PackageReference Include="PepperDashEssentials" Version="2.12.1" >
<ExcludeAssets>runtime</ExcludeAssets>
</PackageReference>
</ItemGroup>