pepperdash/Essentials
1
0
Fork 0
mirror of https://github.com/PepperDash/Essentials.git synced 2026-02-04 23:35:02 +00:00
Code Issues Packages Projects Releases Wiki Activity

esc-544, initial fixes to routing and de-routing

Browse Source
This commit is contained in:
Heath Volmer
2017-10-18 10:25:06 -06:00
parent 07168f0f5b
commit 91cc452e03
15 changed files with 113 additions and 538 deletions
Download Patch File Download Diff File Expand all files Collapse all files

92
Essentials Core/PepperDashEssentialsBase/Devices/MOVED TO CORE Device.cs
View File

@@ -1,92 +0,0 @@
//using System;
//using System.Collections.Generic;
//using System.Linq;
//namespace PepperDash.Essentials.Core
//{
// //*********************************************************************************************************
// /// <summary>
// /// The core event and status-bearing class that most if not all device and connectors can derive from.
// /// </summary>
// public class Device : IKeyed
// {
// public string Key { get; protected set; }
// public string Name { get; protected set; }
// public bool Enabled { get; protected set; }
// List<Action> _PreActivationActions;
// List<Action> _PostActivationActions;
// public static Device DefaultDevice { get { return _DefaultDevice; } }
// static Device _DefaultDevice = new Device("Default", "Default");
// /// <summary>
// /// Base constructor for all Devices.
// /// </summary>
// /// <param name="key"></param>
// public Device(string key)
// {
// Key = key;
// if (key.Contains('.')) Debug.Console(0, this, "WARNING: Device name's should not include '.'");
// Name = "";
// }
// public Device(string key, string name) : this(key)
// {
// Name = name;
// }
// public void AddPreActivationAction(Action act)
// {
// if (_PreActivationActions == null)
// _PreActivationActions = new List<Action>();
// _PreActivationActions.Add(act);
// }
// public void AddPostActivationAction(Action act)
// {
// if (_PostActivationActions == null)
// _PostActivationActions = new List<Action>();
// _PostActivationActions.Add(act);
// }
// /// <summary>
// /// Gets this device ready to be used in the system. Runs any added pre-activation items, and
// /// all post-activation at end. Classes needing additional logic to
// /// run should override CustomActivate()
// /// </summary>
// public bool Activate()
// {
// if (_PreActivationActions != null)
// _PreActivationActions.ForEach(a => a.Invoke());
// var result = CustomActivate();
// if(result && _PostActivationActions != null)
// _PostActivationActions.ForEach(a => a.Invoke());
// return result;
// }
// /// <summary>
// /// Called in between Pre and PostActivationActions when Activate() is called.
// /// Override to provide addtitional setup when calling activation. Overriding classes
// /// do not need to call base.CustomActivate()
// /// </summary>
// /// <returns>true if device activated successfully.</returns>
// public virtual bool CustomActivate() { return true; }
// /// <summary>
// /// Call to deactivate device - unlink events, etc. Overriding classes do not
// /// need to call base.Deactivate()
// /// </summary>
// /// <returns></returns>
// public virtual bool Deactivate() { return true; }
// /// <summary>
// /// Helper method to check object for bool value false and fire an Action method
// /// </summary>
// /// <param name="o">Should be of type bool, others will be ignored</param>
// /// <param name="a">Action to be run when o is false</param>
// public void OnFalse(object o, Action a)
// {
// if (o is bool && !(bool)o) a();
// }
// }
//}

44
Essentials Core/PepperDashEssentialsBase/Devices/REMOVE DefaultDevice.cs
View File

@@ -1,44 +0,0 @@
//using System;
//using System.Collections.Generic;
//using System.Linq;
//using Crestron.SimplSharp;
//using Crestron.SimplSharpPro;
//using Crestron.SimplSharpPro.DeviceSupport;
//using Crestron.SimplSharpPro.EthernetCommunication;
//using Crestron.SimplSharpPro.UI;
//using PepperDash.Core;
//namespace PepperDash.Essentials.Core
//{
//[Obsolete]
// public class PresentationDevice : Device, IPresentationSource
// {
// public PresentationSourceType Type { get; protected set; }
// public string IconName { get { return "Blank"; } set { } }
// public BoolFeedback HasPowerOnFeedback { get; protected set; }
// PresentationDevice()
// : base("Default", "Default")
// {
// HasPowerOnFeedback = new BoolFeedback(CommonBoolCue.HasPowerFeedback, () => false);
// Type = PresentationSourceType.None;
// }
// /// <summary>
// /// Returns a "default" presentation device, with no abilities.
// /// </summary>
// public static IPresentationSource Default
// {
// get
// {
// if (_Default == null)
// _Default = new PresentationDevice();
// return _Default;
// }
// }
// static IPresentationSource _Default;
// }
//}

52
Essentials Core/PepperDashEssentialsBase/Devices/REMOVE DeviceConfig.cs
View File

@@ -1,52 +0,0 @@
//using System;
//using System.Collections.Generic;
//using System.Linq;
//using System.Text;
//using Crestron.SimplSharp;
//using Crestron.SimplSharpPro;
//using Newtonsoft.Json;
//using Newtonsoft.Json.Linq;
//namespace PepperDash.Essentials.Core
//{
// public class DeviceConfig
// {
// public string Key { get; set; }
// public string Name { get; set; }
// public string Type { get; set; }
// [JsonConverter(typeof(DevicePropertiesJsonConverter))]
// public JToken Properties { get; set; }
// }
// /// <summary>
// /// The gist of this converter: The comspec JSON comes in with normal values that need to be converted
// /// into enum names. This converter takes the value and applies the appropriate enum's name prefix to the value
// /// and then returns the enum value using Enum.Parse
// /// </summary>
// public class DevicePropertiesJsonConverter : JsonConverter
// {
// public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
// {
// return JObject.Load(reader);
// }
// /// <summary>
// /// This will be hit with every value in the ComPortConfig class. We only need to
// /// do custom conversion on the comspec items.
// /// </summary>
// public override bool CanConvert(Type objectType)
// {
// return true;
// }
// public override bool CanRead { get { return true; } }
// public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
// {
// throw new NotImplementedException();
// }
// }
//}

50
Essentials Core/PepperDashEssentialsBase/Devices/REPLACE DvdDeviceBase.cs
View File

@@ -1,50 +0,0 @@
//using System;
//using System.Collections.Generic;
//using System.Linq;
//using System.Text;
//using Crestron.SimplSharp;
//using Crestron.SimplSharpPro;
//using Crestron.SimplSharpPro.DeviceSupport;
//using PepperDash.Core;
//namespace PepperDash.Essentials.Core
//{
// public abstract class DvdDeviceBase : Device, IPresentationSource, IHasCueActionList
// {
// public DvdDeviceBase(string key, string name)
// : base(key, name)
// {
// HasPowerOnFeedback = new BoolFeedback(() => false);
// }
// #region IPresentationSource Members
// PresentationSourceType IPresentationSource.Type
// {
// get { return PresentationSourceType.Dvd; }
// }
// public string IconName
// {
// get
// {
// return "DVD";
// }
// set { }
// }
// public virtual BoolFeedback HasPowerOnFeedback { get; private set; }
// #endregion
// #region IFunctionList Members
// public abstract List<CueActionPair> CueActionList { get; }
// #endregion
// }
//}

130
Essentials Core/PepperDashEssentialsBase/Devices/REPLACE IrDvdBase.cs
View File

@@ -1,130 +0,0 @@
//using System;
//using System.Collections.Generic;
//using System.Linq;
//using Crestron.SimplSharpPro;
//using PepperDash.Essentials.Core;
//using PepperDash.Core;
//namespace PepperDash.Essentials.Core
//{
// /// <summary>
// /// This DVD class should cover most IR, one-way DVD and Bluray fuctions
// /// </summary>
// public class IrDvdBase : Device, IHasCueActionList,
// IPresentationSource, IAttachVideoStatus, IHasFeedback, IRoutingOutputs
// {
// public PresentationSourceType Type { get; protected set; }
// public string IconName { get; set; }
// public BoolFeedback HasPowerOnFeedback { get; private set; }
// public IrOutputPortController IrPort { get; private set; }
// public RoutingOutputPort HdmiOut { get; private set; }
// #region IRoutingOutputs Members
// /// <summary>
// /// Options: hdmi
// /// </summary>
// public RoutingPortCollection<RoutingOutputPort> OutputPorts { get; private set; }
// #endregion
// public IrDvdBase(string key, string name, IROutputPort port, IrDriverInfo driverInfo)
// : base(key, name)
// {
// IrPort = new IrOutputPortController("ir-" + key, port, driverInfo.FileName);
// Type = PresentationSourceType.Dvd;
// IconName = "Bluray";
// HasPowerOnFeedback = new BoolFeedback(CommonBoolCue.HasPowerFeedback, () => false);
// HdmiOut = new RoutingOutputPort("HDMI", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, 0, this);
// OutputPorts = new RoutingPortCollection<RoutingOutputPort>()
// {
// HdmiOut
// };
// CueActionList = IrPort.GetUOsForIrCommands(driverInfo.IrMap);
// }
// public IrDvdBase(string key, string name, IROutputPort port, string irDriverFilepath)
// : base(key, name)
// {
// IrPort = new IrOutputPortController("ir-" + key, port, irDriverFilepath);
// Type = PresentationSourceType.Dvd;
// IconName = "Bluray";
// HasPowerOnFeedback = new BoolFeedback(CommonBoolCue.HasPowerFeedback, () => false);
// HdmiOut = new RoutingOutputPort("HDMI", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, 0, this);
// OutputPorts = new RoutingPortCollection<RoutingOutputPort>()
// {
// HdmiOut
// };
// var numToIr = new Dictionary<Cue, string>
// {
// { CommonBoolCue.Power, IROutputStandardCommands.IROut_POWER },
// { CommonBoolCue.PowerOff, IROutputStandardCommands.IROut_POWER_OFF },
// { CommonBoolCue.PowerOn, IROutputStandardCommands.IROut_POWER_ON },
// { CommonBoolCue.Replay, IROutputStandardCommands.IROut_REPLAY },
// { CommonBoolCue.Play, IROutputStandardCommands.IROut_PLAY },
// { CommonBoolCue.Pause, IROutputStandardCommands.IROut_PAUSE },
// { CommonBoolCue.Stop, IROutputStandardCommands.IROut_STOP },
// { CommonBoolCue.ChapPrevious, IROutputStandardCommands.IROut_TRACK_MINUS },
// { CommonBoolCue.ChapNext, IROutputStandardCommands.IROut_TRACK_PLUS },
// { CommonBoolCue.Rewind, IROutputStandardCommands.IROut_RSCAN },
// { CommonBoolCue.Ffwd, IROutputStandardCommands.IROut_FSCAN },
// { CommonBoolCue.RStep, IROutputStandardCommands.IROut_R_STEP },
// { CommonBoolCue.FStep, IROutputStandardCommands.IROut_F_STEP },
// { CommonBoolCue.Exit, IROutputStandardCommands.IROut_EXIT },
// { CommonBoolCue.Home, IROutputStandardCommands.IROut_HOME },
// { CommonBoolCue.Menu, IROutputStandardCommands.IROut_MENU },
// { CommonBoolCue.PopUp, IROutputStandardCommands.IROut_POPUPMENU },
// { CommonBoolCue.Up, IROutputStandardCommands.IROut_UP_ARROW },
// { CommonBoolCue.Down, IROutputStandardCommands.IROut_DN_ARROW },
// { CommonBoolCue.Left, IROutputStandardCommands.IROut_LEFT_ARROW },
// { CommonBoolCue.Right, IROutputStandardCommands.IROut_RIGHT_ARROW },
// { CommonBoolCue.Select, IROutputStandardCommands.IROut_ENTER },
// { CommonBoolCue.Info, IROutputStandardCommands.IROut_INFO },
// { CommonBoolCue.Red, IROutputStandardCommands.IROut_RED },
// { CommonBoolCue.Green, IROutputStandardCommands.IROut_GREEN },
// { CommonBoolCue.Yellow, IROutputStandardCommands.IROut_YELLOW },
// { CommonBoolCue.Blue, IROutputStandardCommands.IROut_BLUE },
// { CommonBoolCue.Digit0, IROutputStandardCommands.IROut_0 },
// { CommonBoolCue.Digit1, IROutputStandardCommands.IROut_1 },
// { CommonBoolCue.Digit2, IROutputStandardCommands.IROut_2 },
// { CommonBoolCue.Digit3, IROutputStandardCommands.IROut_3 },
// { CommonBoolCue.Digit4, IROutputStandardCommands.IROut_4 },
// { CommonBoolCue.Digit5, IROutputStandardCommands.IROut_5 },
// { CommonBoolCue.Digit6, IROutputStandardCommands.IROut_6 },
// { CommonBoolCue.Digit7, IROutputStandardCommands.IROut_7 },
// { CommonBoolCue.Digit8, IROutputStandardCommands.IROut_8 },
// { CommonBoolCue.Digit9, IROutputStandardCommands.IROut_9 },
// { CommonBoolCue.Audio, "AUDIO" },
// { CommonBoolCue.Subtitle, "SUBTITLE" },
// { CommonBoolCue.Setup, "SETUP" },
// };
// CueActionList = IrPort.GetUOsForIrCommands(numToIr);
// }
// public List<Feedback> Feedbacks
// {
// get { return this.GetVideoStatuses().ToList(); }
// }
// #region IFunctionList Members
// public List<CueActionPair> CueActionList { get; set; }
// #endregion
// }
// public class IrDriverInfo
// {
// public Dictionary<Cue, string> IrMap { get; set; }
// public string FileName { get; set; }
// }
//}

143
Essentials Core/PepperDashEssentialsBase/Devices/REPLACE IrSetTopBoxBase.cs
View File

@@ -1,143 +0,0 @@
//using System;
//using System.Collections.Generic;
//using System.Linq;
//using Crestron.SimplSharpPro;
//using PepperDash.Essentials.Core;
//using PepperDash.Essentials.Core.Presets;
//using PepperDash.Core;
//namespace PepperDash.Essentials.Core
//{
// /// <summary>
// /// This DVD class should cover most IR, one-way DVD and Bluray fuctions
// /// </summary>
// public class IrSetTopBoxBase : Device, IHasCueActionList,
// IPresentationSource, IAttachVideoStatus, IHasFeedback, IRoutingOutputs, IHasSetTopBoxProperties
// {
// public PresentationSourceType Type { get; protected set; }
// public string IconName { get; set; }
// public BoolFeedback HasPowerOnFeedback { get; private set; }
// public IrOutputPortController IrPort { get; private set; }
// public DevicePresetsModel PresetsModel { get; private set; }
// #region IRoutingOutputs Members
// /// <summary>
// /// Options: hdmi
// /// </summary>
// public RoutingPortCollection<RoutingOutputPort> OutputPorts { get; private set; }
// #endregion
// public IrSetTopBoxBase(string key, string name, IROutputPort port, string irDriverFilepath)
// : base(key, name)
// {
// IrPort = new IrOutputPortController("ir-" + key, port, irDriverFilepath);
// Type = PresentationSourceType.SetTopBox;
// IconName = "TV";
// HasPowerOnFeedback = new BoolFeedback(CommonBoolCue.HasPowerFeedback, () => false);
// OutputPorts = new RoutingPortCollection<RoutingOutputPort>()
// {
// new RoutingOutputPort("HDMI", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, 0, this)
// };
// }
// public void LoadPresets(string filePath)
// {
// //PresetsModel = new DevicePresetsModel(Key + "-presets", this, filePath);
// //DeviceManager.AddDevice(PresetsModel);
// }
// #region IDeviceWithOutputs Members
// public List<Feedback> Feedbacks
// {
// get { return this.GetVideoStatuses().ToList(); }
// }
// #endregion
// #region IFunctionList Members
// public List<CueActionPair> CueActionList
// {
// get
// {
// // This might be the best way to get the words back into functions
// new BoolCueActionPair(CommonBoolCue.Power, b => IrPort.PressRelease(IROutputStandardCommands.IROut_POWER, b));
// new BoolCueActionPair(CommonBoolCue.PowerOn, b => IrPort.PressRelease(IROutputStandardCommands.IROut_POWER_ON, b));
// new BoolCueActionPair(CommonBoolCue.PowerOff, b => IrPort.PressRelease(IROutputStandardCommands.IROut_POWER_OFF, b));
// new BoolCueActionPair(CommonBoolCue.ChannelUp, b => IrPort.PressRelease(IROutputStandardCommands.IROut_CH_PLUS, b));
// var numToIr = new Dictionary<Cue, string>
// {
// { CommonBoolCue.Power, IROutputStandardCommands.IROut_POWER },
// { CommonBoolCue.PowerOn, IROutputStandardCommands.IROut_POWER_ON },
// { CommonBoolCue.PowerOff, IROutputStandardCommands.IROut_POWER_OFF },
// { CommonBoolCue.ChannelUp, IROutputStandardCommands.IROut_CH_PLUS },
// { CommonBoolCue.ChannelDown, IROutputStandardCommands.IROut_CH_MINUS },
// { CommonBoolCue.Last, IROutputStandardCommands.IROut_LAST },
// { CommonBoolCue.Play, IROutputStandardCommands.IROut_PLAY },
// { CommonBoolCue.Pause, IROutputStandardCommands.IROut_PAUSE },
// { CommonBoolCue.Stop, IROutputStandardCommands.IROut_STOP },
// { CommonBoolCue.ChapPrevious, IROutputStandardCommands.IROut_TRACK_MINUS },
// { CommonBoolCue.ChapNext, IROutputStandardCommands.IROut_TRACK_PLUS },
// { CommonBoolCue.Rewind, IROutputStandardCommands.IROut_RSCAN },
// { CommonBoolCue.Ffwd, IROutputStandardCommands.IROut_FSCAN },
// { CommonBoolCue.Replay, IROutputStandardCommands.IROut_REPLAY },
// { CommonBoolCue.Advance, "ADVANCE" },
// { CommonBoolCue.Record, IROutputStandardCommands.IROut_RECORD },
// { CommonBoolCue.Exit, IROutputStandardCommands.IROut_EXIT },
// { CommonBoolCue.Menu, IROutputStandardCommands.IROut_MENU },
// { CommonBoolCue.List, IROutputStandardCommands.IROut_DVR },
// { CommonBoolCue.Dvr, IROutputStandardCommands.IROut_DVR },
// { CommonBoolCue.Back, IROutputStandardCommands.IROut_BACK },
// { CommonBoolCue.Up, IROutputStandardCommands.IROut_UP_ARROW },
// { CommonBoolCue.Down, IROutputStandardCommands.IROut_DN_ARROW },
// { CommonBoolCue.Left, IROutputStandardCommands.IROut_LEFT_ARROW },
// { CommonBoolCue.Right, IROutputStandardCommands.IROut_RIGHT_ARROW },
// { CommonBoolCue.Select, IROutputStandardCommands.IROut_ENTER },
// { CommonBoolCue.Guide, IROutputStandardCommands.IROut_GUIDE },
// { CommonBoolCue.PageUp, IROutputStandardCommands.IROut_PAGE_UP },
// { CommonBoolCue.PageDown, IROutputStandardCommands.IROut_PAGE_DOWN },
// { CommonBoolCue.Info, IROutputStandardCommands.IROut_INFO },
// { CommonBoolCue.Red, IROutputStandardCommands.IROut_RED },
// { CommonBoolCue.Green, IROutputStandardCommands.IROut_GREEN },
// { CommonBoolCue.Yellow, IROutputStandardCommands.IROut_YELLOW },
// { CommonBoolCue.Blue, IROutputStandardCommands.IROut_BLUE },
// { CommonBoolCue.Digit0, IROutputStandardCommands.IROut_0 },
// { CommonBoolCue.Digit1, IROutputStandardCommands.IROut_1 },
// { CommonBoolCue.Digit2, IROutputStandardCommands.IROut_2 },
// { CommonBoolCue.Digit3, IROutputStandardCommands.IROut_3 },
// { CommonBoolCue.Digit4, IROutputStandardCommands.IROut_4 },
// { CommonBoolCue.Digit5, IROutputStandardCommands.IROut_5 },
// { CommonBoolCue.Digit6, IROutputStandardCommands.IROut_6 },
// { CommonBoolCue.Digit7, IROutputStandardCommands.IROut_7 },
// { CommonBoolCue.Digit8, IROutputStandardCommands.IROut_8 },
// { CommonBoolCue.Digit9, IROutputStandardCommands.IROut_9 },
// { CommonBoolCue.Dash, "DASH" },
// };
// return IrPort.GetUOsForIrCommands(numToIr);
// }
// }
// #endregion
// #region IHasSetTopBoxProperties Members
// public bool HasDpad { get; set; }
// public bool HasPreset { get; set; }
// public bool HasDvr { get; set; }
// public bool HasNumbers { get; set; }
// #endregion
// }
//}

7
Essentials Core/PepperDashEssentialsBase/PepperDash_Essentials_Core.csproj
View File

@@ -120,7 +120,6 @@
<Compile Include="Constants\CommonCues.cs" />
<Compile Include="Devices\DisplayUiConstants.cs" />
<Compile Include="Devices\IUsageTracking.cs" />
<Compile Include="Devices\REMOVE DeviceConfig.cs" />
<Compile Include="Devices\DeviceJsonApi.cs" />
<Compile Include="Devices\SourceListItem.cs" />
<Compile Include="DeviceTypeInterfaces\IDisplayBasic.cs" />
@@ -143,6 +142,7 @@
<Compile Include="Feedbacks\BoolFeedbackOneShot.cs" />
<Compile Include="Ramps and Increments\NumericalHelpers.cs" />
<Compile Include="Ramps and Increments\UshortSigIncrementer.cs" />
<Compile Include="Routing\DummyRoutingInputsDevice.cs" />
<Compile Include="Routing\ICardPortsDevice.cs" />
<Compile Include="InUseTracking\IInUseTracking.cs" />
<Compile Include="InUseTracking\InUseTracking.cs" />
@@ -152,10 +152,7 @@
<Compile Include="Monitoring\StatusMonitorBase.cs" />
<Compile Include="Monitoring\Interfaces and things.cs" />
<Compile Include="Monitoring\GenericCommunicationMonitor.cs" />
<Compile Include="Devices\REPLACE IrSetTopBoxBase.cs" />
<Compile Include="Devices\REPLACE IrDvdBase.cs" />
<Compile Include="Devices\NewInterfaces.cs" />
<Compile Include="Devices\REPLACE DvdDeviceBase.cs" />
<Compile Include="Devices\IAttachVideoStatusExtensions.cs" />
<Compile Include="Devices\IHasFeedbacks.cs" />
<Compile Include="Devices\SmartObjectBaseTypes.cs" />
@@ -201,8 +198,6 @@
<Compile Include="Crestron\CrestronGenericBaseDevice.cs" />
<Compile Include="Debug\Debug.cs" />
<Compile Include="DeviceControlsParentInterfaces\IPresentationSource.cs" />
<Compile Include="Devices\REMOVE DefaultDevice.cs" />
<Compile Include="Devices\MOVED TO CORE Device.cs" />
<Compile Include="Devices\DeviceManager.cs" />
<Compile Include="Devices\IrOutputPortController.cs" />
<Compile Include="Display\DisplayBase.cs" />

36
Essentials Core/PepperDashEssentialsBase/Routing/DummyRoutingInputsDevice.cs Normal file
View File

@@ -0,0 +1,36 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Crestron.SimplSharp;
using PepperDash.Core;
namespace PepperDash.Essentials.Core.Routing
{
public class DummyRoutingInputsDevice : Device, IRoutingSource
{
/// <summary>
/// A single output port, backplane, audioVideo
/// </summary>
public RoutingOutputPort AudioVideoOutputPort { get; private set; }
/// <summary>
/// contains the output port
/// </summary>
public RoutingPortCollection<RoutingOutputPort> OutputPorts
{
get { return new RoutingPortCollection<RoutingOutputPort>() { AudioVideoOutputPort }; }
}
/// <summary>
/// constructor
/// </summary>
/// <param name="key">key for special device</param>
public DummyRoutingInputsDevice(string key) : base(key)
{
AudioVideoOutputPort = new RoutingOutputPort("internal", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.BackplaneOnly,
null, this, true);
}
}
}

19
Essentials Core/PepperDashEssentialsBase/Routing/IRoutingInputsExtensions.cs
View File

@@ -30,7 +30,7 @@ namespace PepperDash.Essentials.Core
var newRoute = destination.GetRouteToSource(source, signalType);
if (newRoute == null) return;
RouteDescriptorCollection.DefaultCollection.AddRouteDescriptor(newRoute);
//Debug.Console(1, destination, "Executing new route");
Debug.Console(2, destination, "Executing full route");
newRoute.ExecuteRoutes();
}
@@ -102,16 +102,16 @@ namespace PepperDash.Essentials.Core
eRoutingSignalType signalType, int cycle, RouteDescriptor routeTable)
{
cycle++;
Debug.Console(2, "GetRouteToSource: {0} {1}--> {2}", cycle, source.Key, destination.Key);
RoutingInputPort goodInputPort = null;
var destDevInputTies = TieLineCollection.Default.Where(t =>
t.DestinationPort.ParentDevice == destination && (t.Type == signalType || t.Type == eRoutingSignalType.AudioVideo));
// find a direct tie
var directTie = destDevInputTies.FirstOrDefault(
t =>// !(t.SourcePort.ParentDevice is IRoutingInputsOutputs) // why????
//&&
t.DestinationPort.ParentDevice == destination
t => t.DestinationPort.ParentDevice == destination
&& t.SourcePort.ParentDevice == source);
RoutingInputPort goodInputPort = null;
if (directTie != null) // Found a tie directly to the source
{
goodInputPort = directTie.DestinationPort;
@@ -264,14 +264,14 @@ namespace PepperDash.Essentials.Core
{
foreach (var route in Routes)
{
Debug.Console(2, route.ToString());
Debug.Console(2, "ExecuteRoutes: {0}", route.ToString());
if (route.SwitchingDevice is IRoutingSinkWithSwitching)
(route.SwitchingDevice as IRoutingSinkWithSwitching).ExecuteSwitch(route.InputPort.Selector);
else if (route.SwitchingDevice is IRouting)
{
(route.SwitchingDevice as IRouting).ExecuteSwitch(route.InputPort.Selector, route.OutputPort.Selector, SignalType);
route.OutputPort.InUseTracker.AddUser(Destination, "destination-" + SignalType);
Debug.Console(2, "Port {0} routing. Count={1}", route.OutputPort.Key, route.OutputPort.InUseTracker.InUseCountFeedback.UShortValue);
Debug.Console(2, "Output port {0} routing. Count={1}", route.OutputPort.Key, route.OutputPort.InUseTracker.InUseCountFeedback.UShortValue);
}
}
}
@@ -323,10 +323,11 @@ namespace PepperDash.Essentials.Core
public override string ToString()
{
if(OutputPort == null) // IRoutingSink
if(SwitchingDevice is IRouting)
return string.Format("{0} switches output '{1}' to input '{2}'", SwitchingDevice.Key, OutputPort.Selector, InputPort.Selector);
else
return string.Format("{0} switches to input '{1}'", SwitchingDevice.Key, InputPort.Selector);
return string.Format("{0} switches output '{1}' to input '{2}'", SwitchingDevice.Key, OutputPort.Selector, InputPort.Selector);
}
}
}

12
Essentials Core/PepperDashEssentialsBase/Routing/RoutingInterfaces.cs
View File

@@ -40,6 +40,9 @@ namespace PepperDash.Essentials.Core
}
/// <summary>
/// Endpoint device like a display, that selects inputs
/// </summary>
public interface IRoutingSinkWithSwitching : IRoutingSinkNoSwitching
{
//void ClearRoute();
@@ -53,12 +56,21 @@ namespace PepperDash.Essentials.Core
{
}
/// <summary>
/// Defines a midpoint device as have internal routing. Any devices in the middle of the
/// signal chain, that do switching, must implement this for routing to work otherwise
/// the routing algorithm will treat the IRoutingInputsOutputs device as a passthrough
/// device.
/// </summary>
public interface IRouting : IRoutingInputsOutputs
{
//void ClearRoute(object outputSelector);
void ExecuteSwitch(object inputSelector, object outputSelector, eRoutingSignalType signalType);
}
/// <summary>
/// Defines an IRoutingOutputs devices as being a source - the start of the chain
/// </summary>
public interface IRoutingSource : IRoutingOutputs
{
}

59
Essentials Devices Common/Essentials Devices Common/VideoCodec/CiscoCodec/CiscoSparkCodec.cs
View File

@@ -22,7 +22,8 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.Cisco
enum eCommandType { SessionStart, SessionEnd, Command, GetStatus, GetConfiguration };
public class CiscoSparkCodec : VideoCodecBase, IHasCallHistory, IHasCallFavorites, IHasDirectory,
IHasScheduleAwareness, IOccupancyStatusProvider, IHasCodecLayouts, IHasCodecSelfview, ICommunicationMonitor
IHasScheduleAwareness, IOccupancyStatusProvider, IHasCodecLayouts, IHasCodecSelfview,
ICommunicationMonitor, IRouting
{
public event EventHandler<DirectoryEventArgs> DirectoryResultReturned;
@@ -46,6 +47,11 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.Cisco
public StringFeedback LocalLayoutFeedback { get; private set; }
/// <summary>
/// An internal pseudo-source that is routable and connected to the osd input
/// </summary>
public DummyRoutingInputsDevice OsdSource { get; private set; }
private CodecCommandWithLabel CurrentSelfviewPipPosition;
private CodecCommandWithLabel CurrentLocalLayout;
@@ -183,6 +189,10 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.Cisco
}
}
#warning Figure out where this func is or disappeared to
protected override Func<bool> IncomingCallFeedbackFunc { get { return () => false; } }
private string CliFeedbackRegistrationExpression;
private CodecSyncState SyncState;
@@ -290,18 +300,37 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.Cisco
CodecStatus.Status.Video.Selfview.PIPPosition.ValueChangedAction = ComputeSelfviewPipStatus;
CodecStatus.Status.Video.Layout.LayoutFamily.Local.ValueChangedAction = ComputeLocalLayout;
CodecOsdIn = new RoutingInputPort(RoutingPortNames.CodecOsd, eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, new Action(StopSharing), this);
HdmiIn1 = new RoutingInputPort(RoutingPortNames.HdmiIn1, eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, new Action(SelectPresentationSource1), this);
HdmiIn2 = new RoutingInputPort(RoutingPortNames.HdmiIn2, eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, new Action(SelectPresentationSource2), this);
CodecOsdIn = new RoutingInputPort(RoutingPortNames.CodecOsd, eRoutingSignalType.AudioVideo,
eRoutingPortConnectionType.Hdmi, new Action(StopSharing), this);
HdmiIn1 = new RoutingInputPort(RoutingPortNames.HdmiIn1, eRoutingSignalType.AudioVideo,
eRoutingPortConnectionType.Hdmi, new Action(SelectPresentationSource1), this);
HdmiIn2 = new RoutingInputPort(RoutingPortNames.HdmiIn2, eRoutingSignalType.AudioVideo,
eRoutingPortConnectionType.Hdmi, new Action(SelectPresentationSource2), this);
HdmiOut = new RoutingOutputPort(RoutingPortNames.HdmiOut, eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, null, this);
HdmiOut = new RoutingOutputPort(RoutingPortNames.HdmiOut, eRoutingSignalType.AudioVideo,
eRoutingPortConnectionType.Hdmi, null, this);
InputPorts.Add(CodecOsdIn);
InputPorts.Add(HdmiIn1);
InputPorts.Add(HdmiIn2);
OutputPorts.Add(HdmiOut);
CreateOsdSource();
}
/// <summary>
/// Creates the fake OSD source, and connects it's AudioVideo output to the CodecOsdIn input
/// to enable routing
/// </summary>
void CreateOsdSource()
{
OsdSource = new DummyRoutingInputsDevice(Key + "[osd]");
DeviceManager.AddDevice(OsdSource);
var tl = new TieLine(OsdSource.AudioVideoOutputPort, CodecOsdIn);
TieLineCollection.Default.Add(tl);
}
/// <summary>
/// Starts the HTTP feedback server and syncronizes state of codec
/// </summary>
@@ -735,13 +764,25 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.Cisco
}
}
public override void ExecuteSwitch(object selector)
/// <summary>
///
/// </summary>
/// <param name="selector"></param>
public override void ExecuteSwitch(object selector)
{
(selector as Action)();
PresentationSourceKey = selector.ToString();
}
/// <summary>
/// This is necessary for devices that are "routers" in the middle of the path, even though it only has one output and
/// may only have one input.
/// </summary>
public void ExecuteSwitch(object inputSelector, object outputSelector, eRoutingSignalType signalType)
{
(selector as Action)();
PresentationSourceKey = selector.ToString();
ExecuteSwitch(inputSelector);
}
protected override Func<bool> IncomingCallFeedbackFunc { get { return () => false; } }
/// <summary>
/// Gets the first CallId or returns null

2
Essentials Devices Common/Essentials Devices Common/VideoCodec/VideoCodecBase.cs
View File

@@ -11,7 +11,7 @@ using PepperDash.Essentials.Devices.Common.Codec;
namespace PepperDash.Essentials.Devices.Common.VideoCodec
{
public abstract class VideoCodecBase : Device, IRoutingInputsOutputs,
public abstract class VideoCodecBase : Device, IRoutingInputsOutputs,
IUsageTracking, IHasDialer, IHasSharing, ICodecAudio, iCodecInfo
{
/// <summary>

5
Essentials/PepperDashEssentials/ControlSystem.cs
View File

@@ -162,10 +162,11 @@ namespace PepperDash.Essentials
/// </summary>
public void LoadTieLines()
{
// Make this reusable by clearing the TieLineCollection
// In the future, we can't necessarily just clear here because devices
// might be making their own internal sources/tie lines
var tlc = TieLineCollection.Default;
tlc.Clear();
//tlc.Clear();
foreach (var tieLineConfig in ConfigReader.ConfigObject.TieLines)
{
var newTL = tieLineConfig.GetTieLine();

BIN
Release Package/PepperDashEssentials.cpz
View File

Binary file not shown.

BIN
Release Package/PepperDashEssentials.dll
View File

Binary file not shown.