pepperdash/Essentials
1
0
Fork 0
mirror of https://github.com/PepperDash/Essentials.git synced 2026-08-31 19:08:29 +00:00
Code Issues Projects Releases Packages Wiki Activity

chore: move all files to file-scoped namespace

Browse source
This commit is contained in:
Andrew Welker 2025-07-04 16:02:32 -05:00 • committed by Neil Dorin
parent aaa5b0532b
commit 3ece4f0b7b
522 changed files with 39628 additions and 45678 deletions
Download patch file Download diff file Expand all files Collapse all files

139
src/PepperDash.Essentials.Devices.Common/Codec/Cisco/IPresenterTrack.cs
View file

@ -1,90 +1,89 @@
using PepperDash.Core;
using PepperDash.Essentials.Core;
namespace PepperDash.Essentials.Devices.Common.Codec.Cisco
namespace PepperDash.Essentials.Devices.Common.Codec.Cisco;
/// <summary>
/// Describes the available tracking modes for a Cisco codec's Presenter Track feature.
/// </summary>
public enum ePresenterTrackMode
{
/// <summary>
/// Describes the available tracking modes for a Cisco codec's Presenter Track feature.
/// Presenter Track is turned off.
/// </summary>
public enum ePresenterTrackMode
{
/// <summary>
/// Presenter Track is turned off.
/// </summary>
Off,
/// <summary>
/// Presenter Track follows the speaker's movements.
/// </summary>
Follow,
/// <summary>
/// Presenter Track is set to background mode, where it tracks the speaker but does not actively follow.
/// </summary>
Background,
/// <summary>
/// Presenter Track is set to persistent mode, where it maintains a fixed position or focus on the speaker.
/// </summary>
Persistent
}
Off,
/// <summary>
/// Presenter Track follows the speaker's movements.
/// </summary>
Follow,
/// <summary>
/// Presenter Track is set to background mode, where it tracks the speaker but does not actively follow.
/// </summary>
Background,
/// <summary>
/// Presenter Track is set to persistent mode, where it maintains a fixed position or focus on the speaker.
/// </summary>
Persistent
}
/// <summary>
/// Describes the Presenter Track controls for a Cisco codec.
/// </summary>
public interface IPresenterTrack : IKeyed
{
/// <summary>
///
/// </summary>
bool PresenterTrackAvailability { get; }
/// <summary>
/// Describes the Presenter Track controls for a Cisco codec.
/// Feedback indicating whether Presenter Track is available.
/// </summary>
public interface IPresenterTrack : IKeyed
{
/// <summary>
///
/// </summary>
bool PresenterTrackAvailability { get; }
BoolFeedback PresenterTrackAvailableFeedback { get; }
/// <summary>
/// Feedback indicating whether Presenter Track is available.
/// </summary>
BoolFeedback PresenterTrackAvailableFeedback { get; }
/// <summary>
/// Feedback indicating the current status of Presenter Track is off
/// </summary>
BoolFeedback PresenterTrackStatusOffFeedback { get; }
/// <summary>
/// Feedback indicating the current status of Presenter Track is off
/// </summary>
BoolFeedback PresenterTrackStatusOffFeedback { get; }
/// <summary>
/// Feedback indicating the current status of Presenter Track is follow
/// </summary>
BoolFeedback PresenterTrackStatusFollowFeedback { get; }
/// <summary>
/// Feedback indicating the current status of Presenter Track is follow
/// </summary>
BoolFeedback PresenterTrackStatusFollowFeedback { get; }
/// <summary>
/// Feedback indicating the current status of Presenter Track is background
/// </summary>
BoolFeedback PresenterTrackStatusBackgroundFeedback { get; }
/// <summary>
/// Feedback indicating the current status of Presenter Track is background
/// </summary>
BoolFeedback PresenterTrackStatusBackgroundFeedback { get; }
/// <summary>
/// Feedback indicating the current status of Presenter Track is persistent
/// </summary>
BoolFeedback PresenterTrackStatusPersistentFeedback { get; }
/// <summary>
/// Feedback indicating the current status of Presenter Track is persistent
/// </summary>
BoolFeedback PresenterTrackStatusPersistentFeedback { get; }
/// <summary>
/// Indicates the current status of Presenter Track.
/// </summary>
bool PresenterTrackStatus { get; }
/// <summary>
/// Indicates the current status of Presenter Track.
/// </summary>
bool PresenterTrackStatus { get; }
/// <summary>
/// Turns off Presenter Track.
/// </summary>
void PresenterTrackOff();
/// <summary>
/// Turns off Presenter Track.
/// </summary>
void PresenterTrackOff();
/// <summary>
/// Turns on Presenter Track in follow mode.
/// </summary>
void PresenterTrackFollow();
/// <summary>
/// Turns on Presenter Track in follow mode.
/// </summary>
void PresenterTrackFollow();
/// <summary>
/// Turns on Presenter Track in background mode.
/// </summary>
void PresenterTrackBackground();
/// <summary>
/// Turns on Presenter Track in background mode.
/// </summary>
void PresenterTrackBackground();
/// <summary>
/// Turns on Presenter Track in persistent mode.
/// </summary>
void PresenterTrackPersistent();
}
/// <summary>
/// Turns on Presenter Track in persistent mode.
/// </summary>
void PresenterTrackPersistent();
}

49
src/PepperDash.Essentials.Devices.Common/Codec/Cisco/ISpeakerTrack.cs
View file

@ -1,35 +1,34 @@
using PepperDash.Core;
using PepperDash.Essentials.Core;
namespace PepperDash.Essentials.Devices.Common.Codec.Cisco
namespace PepperDash.Essentials.Devices.Common.Codec.Cisco;
/// <summary>
/// Describes the available tracking modes for a Cisco codec
/// </summary>
public interface ISpeakerTrack : IKeyed
{
/// <summary>
/// Describes the available tracking modes for a Cisco codec
/// Indicates whether Speaker Track is available on the codec.
/// </summary>
public interface ISpeakerTrack : IKeyed
{
/// <summary>
/// Indicates whether Speaker Track is available on the codec.
/// </summary>
bool SpeakerTrackAvailability { get; }
bool SpeakerTrackAvailability { get; }
/// <summary>
///
/// </summary>
BoolFeedback SpeakerTrackAvailableFeedback { get; }
/// <summary>
///
/// </summary>
BoolFeedback SpeakerTrackAvailableFeedback { get; }
/// <summary>
/// Feedback indicating the current status of Speaker Track is off
/// </summary>
bool SpeakerTrackStatus { get; }
/// <summary>
/// Feedback indicating the current status of Speaker Track is off
/// </summary>
bool SpeakerTrackStatus { get; }
/// <summary>
/// Turns Speaker Track off
/// </summary>
void SpeakerTrackOff();
/// <summary>
/// Turns Speaker Track on
/// </summary>
void SpeakerTrackOn();
}
/// <summary>
/// Turns Speaker Track off
/// </summary>
void SpeakerTrackOff();
/// <summary>
/// Turns Speaker Track on
/// </summary>
void SpeakerTrackOn();
}

175
src/PepperDash.Essentials.Devices.Common/Codec/CodecActiveCallItem.cs
View file

@ -1,105 +1,100 @@

using System;
using System;
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;
namespace PepperDash.Essentials.Devices.Common.Codec
namespace PepperDash.Essentials.Devices.Common.Codec;
/// <summary>
/// Represents an active call item for a codec, including details such as name, number, type, status, direction, and duration.
/// </summary>
public class CodecActiveCallItem
{
/// <summary>
/// Represents a CodecActiveCallItem
/// The name associated with the call, if available.
/// </summary>
public class CodecActiveCallItem
{
/// <summary>
/// Gets or sets the Name
/// </summary>
[JsonProperty("name", NullValueHandling = NullValueHandling.Ignore)]
public string Name { get; set; }
/// <summary>
/// Gets or sets the Number
/// </summary>
[JsonProperty("number", NullValueHandling = NullValueHandling.Ignore)]
public string Number { get; set; }
/// <summary>
/// Gets or sets the Type
/// </summary>
[JsonProperty("type", NullValueHandling = NullValueHandling.Ignore)]
[JsonConverter(typeof(StringEnumConverter))]
public eCodecCallType Type { get; set; }
/// <summary>
/// Gets or sets the Status
/// </summary>
[JsonProperty("status", NullValueHandling = NullValueHandling.Ignore)]
[JsonConverter(typeof(StringEnumConverter))]
public eCodecCallStatus Status { get; set; }
/// <summary>
/// Gets or sets the Direction
/// </summary>
[JsonProperty("direction", NullValueHandling = NullValueHandling.Ignore)]
[JsonConverter(typeof(StringEnumConverter))]
public eCodecCallDirection Direction { get; set; }
/// <summary>
/// Gets or sets the Id
/// </summary>
[JsonProperty("id", NullValueHandling = NullValueHandling.Ignore)]
public string Id { get; set; }
/// <summary>
/// Gets or sets the IsOnHold
/// </summary>
[JsonProperty("isOnHold", NullValueHandling = NullValueHandling.Ignore)]
public bool IsOnHold { get; set; }
/// <summary>
/// Gets or sets the Duration
/// </summary>
[JsonProperty("duration", NullValueHandling = NullValueHandling.Ignore)]
public TimeSpan Duration { get; set; }
//public object CallMetaData { get; set; }
/// <summary>
/// Returns true when this call is any status other than
/// Unknown, Disconnected, Disconnecting
/// </summary>
[JsonProperty("isActiveCall", NullValueHandling = NullValueHandling.Ignore)]
public bool IsActiveCall
{
get
{
return !(Status == eCodecCallStatus.Disconnected
|| Status == eCodecCallStatus.Disconnecting
|| Status == eCodecCallStatus.Idle
|| Status == eCodecCallStatus.Unknown);
}
}
}
[JsonProperty("name", NullValueHandling = NullValueHandling.Ignore)]
public string Name { get; set; }
/// <summary>
/// Represents a CodecCallStatusItemChangeEventArgs
/// The phone number associated with the call, if available.
/// </summary>
public class CodecCallStatusItemChangeEventArgs : EventArgs
{
/// <summary>
/// Gets or sets the CallItem
/// </summary>
public CodecActiveCallItem CallItem { get; private set; }
[JsonProperty("number", NullValueHandling = NullValueHandling.Ignore)]
public string Number { get; set; }
/// <summary>
/// Initializes a new instance of the CodecCallStatusItemChangeEventArgs class
/// </summary>
/// <param name="item">The call item that changed</param>
public CodecCallStatusItemChangeEventArgs(CodecActiveCallItem item)
/// <summary>
/// The type of the call, such as audio or video. This is an optional property and may be null if the type is unknown or not applicable.
/// </summary>
[JsonProperty("type", NullValueHandling = NullValueHandling.Ignore)]
[JsonConverter(typeof(StringEnumConverter))]
public eCodecCallType Type { get; set; }
/// <summary>
/// The current status of the call, such as active, on hold, or disconnected. This is an optional property and may be null if the status is unknown or not applicable.
/// </summary>
[JsonProperty("status", NullValueHandling = NullValueHandling.Ignore)]
[JsonConverter(typeof(StringEnumConverter))]
public eCodecCallStatus Status { get; set; }
/// <summary>
/// The direction of the call, such as incoming or outgoing. This is an optional property and may be null if the direction is unknown or not applicable.
/// </summary>
[JsonProperty("direction", NullValueHandling = NullValueHandling.Ignore)]
[JsonConverter(typeof(StringEnumConverter))]
public eCodecCallDirection Direction { get; set; }
/// <summary>
/// A unique identifier for the call, if available. This can be used to track the call across different events and status changes. This is an optional property and may be null if an identifier is not available or applicable.
/// </summary>
[JsonProperty("id", NullValueHandling = NullValueHandling.Ignore)]
public string Id { get; set; }
/// <summary>
/// Indicates whether the call is currently on hold. This is an optional property and may be null if the hold status is unknown or not applicable.
/// </summary>
[JsonProperty("isOnHold", NullValueHandling = NullValueHandling.Ignore)]
public bool IsOnHold { get; set; }
/// <summary>
/// The duration of the call, if available. This can be used to track how long the call has been active. This is an optional property and may be null if the duration is not available or applicable.
/// </summary>
[JsonProperty("duration", NullValueHandling = NullValueHandling.Ignore)]
public TimeSpan Duration { get; set; }
//public object CallMetaData { get; set; }
/// <summary>
/// Returns true when this call is any status other than
/// Unknown, Disconnected, Disconnecting
/// </summary>
[JsonProperty("isActiveCall", NullValueHandling = NullValueHandling.Ignore)]
public bool IsActiveCall
{
get
{
CallItem = item;
return !(Status == eCodecCallStatus.Disconnected
|| Status == eCodecCallStatus.Disconnecting
|| Status == eCodecCallStatus.Idle
|| Status == eCodecCallStatus.Unknown);
}
}
}
/// <summary>
/// Event args for when a call status changes, includes the call item with updated status and details.
/// </summary>
public class CodecCallStatusItemChangeEventArgs : EventArgs
{
/// <summary>
/// The call item that has changed status, including its updated status and details. This property is read-only and is set through the constructor when the event args are created.
/// </summary>
public CodecActiveCallItem CallItem { get; private set; }
/// <summary>
/// Constructor for CodecCallStatusItemChangeEventArgs
/// </summary>
/// <param name="item">The call item that has changed status.</param>
public CodecCallStatusItemChangeEventArgs(CodecActiveCallItem item)
{
CallItem = item;
}
}

30
src/PepperDash.Essentials.Devices.Common/Codec/IHasCallHold.cs
View file

@ -1,20 +1,20 @@
namespace PepperDash.Essentials.Devices.Common.Codec
namespace PepperDash.Essentials.Devices.Common.Codec;
/// <summary>
/// Defines the contract for devices that have call hold functionality
/// </summary>
public interface IHasCallHold
{
/// <summary>
/// Defines the contract for IHasCallHold
/// Put the specified call on hold
/// </summary>
public interface IHasCallHold
{
/// <summary>
/// Put the specified call on hold
/// </summary>
/// <param name="activeCall"></param>
void HoldCall(CodecActiveCallItem activeCall);
/// <param name="activeCall">The call to put on hold</param>
void HoldCall(CodecActiveCallItem activeCall);
/// <summary>
/// Resume the specified call
/// </summary>
/// <param name="activeCall"></param>
void ResumeCall(CodecActiveCallItem activeCall);
}
/// <summary>
/// Resume the specified call
/// </summary>
/// <param name="activeCall">The call to resume</param>
void ResumeCall(CodecActiveCallItem activeCall);
}

67
src/PepperDash.Essentials.Devices.Common/Codec/IHasDoNotDisturb.cs
View file

@ -1,42 +1,41 @@
using PepperDash.Essentials.Core;
namespace PepperDash.Essentials.Devices.Common.Codec
namespace PepperDash.Essentials.Devices.Common.Codec;
/// <summary>
/// Describes a device that has Do Not Disturb mode capability
/// </summary>
public interface IHasDoNotDisturbMode
{
/// <summary>
/// Describes a device that has Do Not Disturb mode capability
/// Indictes whether Do Not Disturb mode is on (Activated)
/// </summary>
public interface IHasDoNotDisturbMode
{
/// <summary>
/// Indictes whether Do Not Disturb mode is on (Activated)
/// </summary>
BoolFeedback DoNotDisturbModeIsOnFeedback { get; }
/// <summary>
/// Activates Do Not Disturb mode
/// </summary>
void ActivateDoNotDisturbMode();
/// <summary>
/// Deactivates Do Not Disturb mode
/// </summary>
void DeactivateDoNotDisturbMode();
/// <summary>
/// Toggles Do Not Disturb mode
/// </summary>
void ToggleDoNotDisturbMode();
}
BoolFeedback DoNotDisturbModeIsOnFeedback { get; }
/// <summary>
/// Defines the contract for devices that support Do Not Disturb mode with timeout functionality
/// Activates Do Not Disturb mode
/// </summary>
public interface IHasDoNotDisturbModeWithTimeout : IHasDoNotDisturbMode
{
/// <summary>
/// Activates Do Not Disturb mode with a timeout
/// </summary>
/// <param name="timeout"></param>
void ActivateDoNotDisturbMode(int timeout);
}
}
void ActivateDoNotDisturbMode();
/// <summary>
/// Deactivates Do Not Disturb mode
/// </summary>
void DeactivateDoNotDisturbMode();
/// <summary>
/// Toggles Do Not Disturb mode
/// </summary>
void ToggleDoNotDisturbMode();
}
/// <summary>
/// Defines the contract for devices that support Do Not Disturb mode with timeout functionality
/// </summary>
public interface IHasDoNotDisturbModeWithTimeout : IHasDoNotDisturbMode
{
/// <summary>
/// Activates Do Not Disturb mode with a timeout
/// </summary>
/// <param name="timeout"></param>
void ActivateDoNotDisturbMode(int timeout);
}

82
src/PepperDash.Essentials.Devices.Common/Codec/IHasExternalSourceSwitching.cs
View file

@ -1,54 +1,54 @@
using System;
using PepperDash.Essentials.Devices.Common.VideoCodec.Cisco;
namespace PepperDash.Essentials.Devices.Common.Codec
namespace PepperDash.Essentials.Devices.Common.Codec;
/// <summary>
/// Defines the contract for devices that support external source switching functionality
/// </summary>
public interface IHasExternalSourceSwitching
{
/// <summary>
/// Defines the contract for IHasExternalSourceSwitching
/// Gets a value indicating whether the external source list is enabled
/// </summary>
public interface IHasExternalSourceSwitching
{
/// <summary>
/// Gets a value indicating whether the external source list is enabled
/// </summary>
bool ExternalSourceListEnabled { get; }
bool ExternalSourceListEnabled { get; }
/// <summary>
/// Gets the external source input port identifier
/// </summary>
string ExternalSourceInputPort { get; }
/// <summary>
/// Gets the port name for external source input switching
/// </summary>
string ExternalSourceInputPort { get; }
/// <summary>
/// Adds an external source to the available sources
/// </summary>
/// <param name="connectorId">The connector identifier</param>
/// <param name="key">The unique key for the source</param>
/// <param name="name">The display name for the source</param>
/// <param name="type">The type of external source</param>
void AddExternalSource(string connectorId, string key, string name, eExternalSourceType type);
/// <summary>
/// Sets the state of the specified external source
/// </summary>
/// <param name="key">The unique key of the external source</param>
/// <param name="mode">The mode to set for the source</param>
void SetExternalSourceState(string key, eExternalSourceMode mode);
/// <summary>
/// Adds an external source to the list of available sources for switching
/// </summary>
/// <param name="connectorId"></param>
/// <param name="key"></param>
/// <param name="name"></param>
/// <param name="type"></param>
void AddExternalSource(string connectorId, string key, string name, eExternalSourceType type);
/// <summary>
/// Clears all external sources from the list
/// </summary>
void ClearExternalSources();
/// <summary>
/// Sets the state of the specified external source
/// </summary>
/// <param name="key">The unique key of the external source</param>
/// <param name="mode">The mode to set for the source</param>
void SetExternalSourceState(string key, eExternalSourceMode mode);
/// <summary>
/// Sets the selected source by its key
/// </summary>
/// <param name="key">The unique key of the source to select</param>
void SetSelectedSource(string key);
/// <summary>
/// Clears all external sources from the list
/// </summary>
void ClearExternalSources();
/// <summary>
/// Sets the action to run when routing between sources
/// </summary>
Action<string, string> RunRouteAction { set; }
}
/// <summary>
/// Sets the selected external source for switching
/// </summary>
/// <param name="key"></param>
void SetSelectedSource(string key);
}
/// <summary>
/// Defines an action to run when an external source is selected for switching.
/// The action takes the key and name of the selected source as parameters.
/// </summary>
Action<string, string> RunRouteAction { set; }
}

92
src/PepperDash.Essentials.Devices.Common/Codec/eCodecCallDirection.cs
View file

@ -1,57 +1,57 @@
namespace PepperDash.Essentials.Devices.Common.Codec
namespace PepperDash.Essentials.Devices.Common.Codec;
/// <summary>
/// Enumeration of eCodecCallDirection values
/// </summary>
public enum eCodecCallDirection
{
/// <summary>
/// Enumeration of eCodecCallDirection values
/// Unknown call direction
/// </summary>
public enum eCodecCallDirection
{
/// <summary>
/// Unknown call direction
/// </summary>
Unknown = 0,
/// <summary>
/// Incoming call direction
/// </summary>
Incoming,
/// <summary>
/// Outgoing call direction
/// </summary>
Outgoing
}
Unknown = 0,
/// <summary>
/// Represents a CodecCallDirection
/// Incoming call direction
/// </summary>
public class CodecCallDirection
{
/// <summary>
/// Takes the Cisco call type and converts to the matching enum
/// </summary>
/// <param name="s"></param>
/// <returns></returns>
/// <summary>
/// ConvertToDirectionEnum method
/// </summary>
public static eCodecCallDirection ConvertToDirectionEnum(string s)
{
switch (s.ToLower())
{
case "incoming":
{
return eCodecCallDirection.Incoming;
}
case "outgoing":
{
return eCodecCallDirection.Outgoing;
}
default:
return eCodecCallDirection.Unknown;
}
Incoming,
/// <summary>
/// Outgoing call direction
/// </summary>
Outgoing
}
/// <summary>
/// Represents a CodecCallDirection
/// </summary>
public class CodecCallDirection
{
/// <summary>
/// Takes the Cisco call type and converts to the matching enum
/// </summary>
/// <param name="s"></param>
/// <returns></returns>
/// <summary>
/// ConvertToDirectionEnum method
/// </summary>
public static eCodecCallDirection ConvertToDirectionEnum(string s)
{
switch (s.ToLower())
{
case "incoming":
{
return eCodecCallDirection.Incoming;
}
case "outgoing":
{
return eCodecCallDirection.Outgoing;
}
default:
return eCodecCallDirection.Unknown;
}
}
}
}

255
src/PepperDash.Essentials.Devices.Common/Codec/eCodecCallStatus.cs
View file

@ -1,139 +1,138 @@
namespace PepperDash.Essentials.Devices.Common.Codec
namespace PepperDash.Essentials.Devices.Common.Codec;
/// <summary>
/// Enumeration of eCodecCallStatus values
/// </summary>
public enum eCodecCallStatus
{
/// <summary>
/// Enumeration of eCodecCallStatus values
/// Unknown call status
/// </summary>
public enum eCodecCallStatus
{
/// <summary>
/// Unknown call status
/// </summary>
Unknown = 0,
/// <summary>
/// Call is connected
/// </summary>
Connected,
/// <summary>
/// Call is connecting
/// </summary>
Connecting,
/// <summary>
/// Call is dialing
/// </summary>
Dialing,
/// <summary>
/// Call is disconnected
/// </summary>
Disconnected,
/// <summary>
/// Call is disconnecting
/// </summary>
Disconnecting,
/// <summary>
/// Early media is being sent/received
/// </summary>
EarlyMedia,
/// <summary>
/// Call is idle
/// </summary>
Idle,
/// <summary>
/// Call is on hold
/// </summary>
OnHold,
/// <summary>
/// Call is ringing
/// </summary>
Ringing,
/// <summary>
/// Call is preserved
/// </summary>
Preserved,
/// <summary>
/// Call is remote preserved
/// </summary>
RemotePreserved,
}
Unknown = 0,
/// <summary>
/// Represents a CodecCallStatus
/// Call is connected
/// </summary>
public class CodecCallStatus
Connected,
/// <summary>
/// Call is connecting
/// </summary>
Connecting,
/// <summary>
/// Call is dialing
/// </summary>
Dialing,
/// <summary>
/// Call is disconnected
/// </summary>
Disconnected,
/// <summary>
/// Call is disconnecting
/// </summary>
Disconnecting,
/// <summary>
/// Early media is being sent/received
/// </summary>
EarlyMedia,
/// <summary>
/// Call is idle
/// </summary>
Idle,
/// <summary>
/// Call is on hold
/// </summary>
OnHold,
/// <summary>
/// Call is ringing
/// </summary>
Ringing,
/// <summary>
/// Call is preserved
/// </summary>
Preserved,
/// <summary>
/// Call is remote preserved
/// </summary>
RemotePreserved,
}
/// <summary>
/// Represents a CodecCallStatus
/// </summary>
public class CodecCallStatus
{
/// <summary>
/// Takes the Cisco call type and converts to the matching enum
/// </summary>
/// <param name="s"></param>
/// <returns></returns>
/// <summary>
/// ConvertToStatusEnum method
/// </summary>
public static eCodecCallStatus ConvertToStatusEnum(string s)
{
/// <summary>
/// Takes the Cisco call type and converts to the matching enum
/// </summary>
/// <param name="s"></param>
/// <returns></returns>
/// <summary>
/// ConvertToStatusEnum method
/// </summary>
public static eCodecCallStatus ConvertToStatusEnum(string s)
switch (s)
{
switch (s)
{
case "Connected":
{
return eCodecCallStatus.Connected;
}
case "Connecting":
{
return eCodecCallStatus.Connecting;
}
case "Dialling":
{
return eCodecCallStatus.Dialing;
}
case "Disconnected":
{
return eCodecCallStatus.Disconnected;
}
case "Disconnecting":
{
return eCodecCallStatus.Disconnecting;
}
case "EarlyMedia":
{
return eCodecCallStatus.EarlyMedia;
}
case "Idle":
{
return eCodecCallStatus.Idle;
}
case "OnHold":
{
return eCodecCallStatus.OnHold;
}
case "Ringing":
{
return eCodecCallStatus.Ringing;
}
case "Preserved":
{
return eCodecCallStatus.Preserved;
}
case "RemotePreserved":
{
return eCodecCallStatus.RemotePreserved;
}
default:
return eCodecCallStatus.Unknown;
}
case "Connected":
{
return eCodecCallStatus.Connected;
}
case "Connecting":
{
return eCodecCallStatus.Connecting;
}
case "Dialling":
{
return eCodecCallStatus.Dialing;
}
case "Disconnected":
{
return eCodecCallStatus.Disconnected;
}
case "Disconnecting":
{
return eCodecCallStatus.Disconnecting;
}
case "EarlyMedia":
{
return eCodecCallStatus.EarlyMedia;
}
case "Idle":
{
return eCodecCallStatus.Idle;
}
case "OnHold":
{
return eCodecCallStatus.OnHold;
}
case "Ringing":
{
return eCodecCallStatus.Ringing;
}
case "Preserved":
{
return eCodecCallStatus.Preserved;
}
case "RemotePreserved":
{
return eCodecCallStatus.RemotePreserved;
}
default:
return eCodecCallStatus.Unknown;
}
}
}
}

125
src/PepperDash.Essentials.Devices.Common/Codec/eCodecCallType.cs
View file

@ -1,76 +1,75 @@
namespace PepperDash.Essentials.Devices.Common.Codec
namespace PepperDash.Essentials.Devices.Common.Codec;
/// <summary>
/// Enumeration of eCodecCallType values
/// </summary>
public enum eCodecCallType
{
/// <summary>
/// Enumeration of eCodecCallType values
/// Unknown call type
/// </summary>
public enum eCodecCallType
{
/// <summary>
/// Unknown call type
/// </summary>
Unknown = 0,
/// <summary>
/// Audio-only call type
/// </summary>
Audio,
/// <summary>
/// Video call type
/// </summary>
Video,
/// <summary>
/// Audio call that can be escalated to video
/// </summary>
AudioCanEscalate,
/// <summary>
/// Forward all call type
/// </summary>
ForwardAllCall
}
Unknown = 0,
/// <summary>
/// Represents a CodecCallType
/// Audio-only call type
/// </summary>
public class CodecCallType
Audio,
/// <summary>
/// Video call type
/// </summary>
Video,
/// <summary>
/// Audio call that can be escalated to video
/// </summary>
AudioCanEscalate,
/// <summary>
/// Forward all call type
/// </summary>
ForwardAllCall
}
/// <summary>
/// Represents a CodecCallType
/// </summary>
public class CodecCallType
{
/// <summary>
/// Takes the Cisco call type and converts to the matching enum
/// </summary>
/// <param name="s"></param>
/// <returns></returns>
/// <summary>
/// ConvertToTypeEnum method
/// </summary>
public static eCodecCallType ConvertToTypeEnum(string s)
{
/// <summary>
/// Takes the Cisco call type and converts to the matching enum
/// </summary>
/// <param name="s"></param>
/// <returns></returns>
/// <summary>
/// ConvertToTypeEnum method
/// </summary>
public static eCodecCallType ConvertToTypeEnum(string s)
switch (s)
{
switch (s)
{
case "Audio":
{
return eCodecCallType.Audio;
}
case "Video":
{
return eCodecCallType.Video;
}
case "AudioCanEscalate":
{
return eCodecCallType.AudioCanEscalate;
}
case "ForwardAllCall":
{
return eCodecCallType.ForwardAllCall;
}
default:
return eCodecCallType.Unknown;
}
case "Audio":
{
return eCodecCallType.Audio;
}
case "Video":
{
return eCodecCallType.Video;
}
case "AudioCanEscalate":
{
return eCodecCallType.AudioCanEscalate;
}
case "ForwardAllCall":
{
return eCodecCallType.ForwardAllCall;
}
default:
return eCodecCallType.Unknown;
}
}
}

89
src/PepperDash.Essentials.Devices.Common/Codec/eMeetingPrivacy.cs
View file

@ -1,56 +1,55 @@
namespace PepperDash.Essentials.Devices.Common.Codec
namespace PepperDash.Essentials.Devices.Common.Codec;
/// <summary>
/// Enumeration of eMeetingPrivacy values
/// </summary>
public enum eMeetingPrivacy
{
/// <summary>
/// Enumeration of eMeetingPrivacy values
/// Unknown meeting privacy level
/// </summary>
public enum eMeetingPrivacy
{
/// <summary>
/// Unknown meeting privacy level
/// </summary>
Unknown = 0,
/// <summary>
/// Public meeting
/// </summary>
Public,
/// <summary>
/// Private meeting
/// </summary>
Private
}
Unknown = 0,
/// <summary>
/// Represents a CodecCallPrivacy
/// Public meeting
/// </summary>
public class CodecCallPrivacy
{
/// <summary>
/// Takes the Cisco privacy type and converts to the matching enum
/// </summary>
/// <param name="s"></param>
/// <returns></returns>
/// <summary>
/// ConvertToDirectionEnum method
/// </summary>
public static eMeetingPrivacy ConvertToDirectionEnum(string s)
{
switch (s.ToLower())
{
case "public":
{
return eMeetingPrivacy.Public;
}
case "private":
{
return eMeetingPrivacy.Private;
}
default:
return eMeetingPrivacy.Unknown;
}
Public,
/// <summary>
/// Private meeting
/// </summary>
Private
}
/// <summary>
/// Represents a CodecCallPrivacy
/// </summary>
public class CodecCallPrivacy
{
/// <summary>
/// Takes the Cisco privacy type and converts to the matching enum
/// </summary>
/// <param name="s"></param>
/// <returns></returns>
/// <summary>
/// ConvertToDirectionEnum method
/// </summary>
public static eMeetingPrivacy ConvertToDirectionEnum(string s)
{
switch (s)
{
case "public":
{
return eMeetingPrivacy.Public;
}
case "private":
{
return eMeetingPrivacy.Private;
}
default:
return eMeetingPrivacy.Unknown;
}
}
}

15
src/PepperDash.Essentials.Devices.Common/Codec/iCodecAudio.cs
View file

@ -1,12 +1,11 @@
using PepperDash.Essentials.Core;
namespace PepperDash.Essentials.Devices.Common.Codec
{
/// <summary>
/// Defines minimum volume controls for a codec device with dialing capabilities
/// </summary>
public interface ICodecAudio : IBasicVolumeWithFeedback, IPrivacy
{
namespace PepperDash.Essentials.Devices.Common.Codec;
/// <summary>
/// Defines minimum volume controls for a codec device with dialing capabilities
/// </summary>
public interface ICodecAudio : IBasicVolumeWithFeedback, IPrivacy
{
}
}

48
src/PepperDash.Essentials.Devices.Common/Codec/iHasCallFavorites.cs
View file

@ -1,34 +1,34 @@
using System.Collections.Generic;
namespace PepperDash.Essentials.Devices.Common.Codec
namespace PepperDash.Essentials.Devices.Common.Codec;
/// <summary>
/// Defines the contract for IHasCallFavorites
/// </summary>
public interface IHasCallFavorites
{
/// <summary>
/// Defines the contract for IHasCallFavorites
/// Gets the call favorites for this device
/// </summary>
public interface IHasCallFavorites
{
/// <summary>
/// Gets the call favorites for this device
/// </summary>
CodecCallFavorites CallFavorites { get; }
}
CodecCallFavorites CallFavorites { get; }
}
/// <summary>
/// Represents a CodecCallFavorites
/// </summary>
public class CodecCallFavorites
{
/// <summary>
/// Gets or sets the Favorites
/// </summary>
public List<CodecActiveCallItem> Favorites { get; set; }
/// <summary>
/// Represents a CodecCallFavorites
/// Initializes a new instance of the CodecCallFavorites class
/// </summary>
public class CodecCallFavorites
public CodecCallFavorites()
{
/// <summary>
/// Gets or sets the Favorites
/// </summary>
public List<CodecActiveCallItem> Favorites { get; set; }
/// <summary>
/// Initializes a new instance of the CodecCallFavorites class
/// </summary>
public CodecCallFavorites()
{
Favorites = new List<CodecActiveCallItem>();
}
Favorites = new List<CodecActiveCallItem>();
}
}
}

259
src/PepperDash.Essentials.Devices.Common/Codec/iHasCallHistory.cs
View file

@ -6,188 +6,131 @@ using Newtonsoft.Json;
using Newtonsoft.Json.Converters;
using PepperDash.Essentials.Devices.Common.VideoCodec;
namespace PepperDash.Essentials.Devices.Common.Codec
namespace PepperDash.Essentials.Devices.Common.Codec;
public interface IHasCallHistory
{
CodecCallHistory CallHistory { get; }
void RemoveCallHistoryEntry(CodecCallHistory.CallHistoryEntry entry);
}
public enum eCodecOccurrenceType
{
Unknown = 0,
Placed = 1,
Received = 2,
NoAnswer = 3,
}
/// <summary>
/// Represents the recent call history for a codec device
/// </summary>
public class CodecCallHistory
{
public event EventHandler<EventArgs> RecentCallsListHasChanged;
public List<CallHistoryEntry> RecentCalls { get; private set; }
/// <summary>
/// Defines the contract for IHasCallHistory
/// Item that gets added to the list when there are no recent calls in history
/// </summary>
public interface IHasCallHistory
{
/// <summary>
/// Gets the call history for this device
/// </summary>
CodecCallHistory CallHistory { get; }
CallHistoryEntry ListEmptyEntry;
/// <summary>
/// Removes the specified call history entry
/// </summary>
/// <param name="entry">The call history entry to remove</param>
void RemoveCallHistoryEntry(CodecCallHistory.CallHistoryEntry entry);
public CodecCallHistory()
{
ListEmptyEntry = new CallHistoryEntry() { Name = "No Recent Calls" };
RecentCalls = new List<CallHistoryEntry>();
RecentCalls.Add(ListEmptyEntry);
}
void OnRecentCallsListChange()
{
var handler = RecentCallsListHasChanged;
if (handler != null)
{
handler(this, new EventArgs());
}
}
public void RemoveEntry(CallHistoryEntry entry)
{
RecentCalls.Remove(entry);
OnRecentCallsListChange();
}
/// <summary>
/// Enumeration of eCodecOccurrenceType values
/// Generic call history entry, not device specific
/// </summary>
public enum eCodecOccurrenceType
public class CallHistoryEntry : CodecActiveCallItem
{
/// <summary>
/// Unknown occurrence type
/// </summary>
Unknown = 0,
/// <summary>
/// Call was placed (outgoing)
/// </summary>
Placed = 1,
/// <summary>
/// Call was received (incoming)
/// </summary>
Received = 2,
/// <summary>
/// Call received no answer
/// </summary>
NoAnswer = 3,
[JsonConverter(typeof(IsoDateTimeConverter))]
[JsonProperty("startTime")]
public DateTime StartTime { get; set; }
[JsonConverter(typeof(StringEnumConverter))]
[JsonProperty("occurrenceType")]
public eCodecOccurrenceType OccurrenceType { get; set; }
[JsonProperty("occurrenceHistoryId")]
public string OccurrenceHistoryId { get; set; }
}
/// <summary>
/// Represents a CodecCallHistory
/// Converts a list of call history entries returned by a Cisco codec to the generic list type
/// </summary>
public class CodecCallHistory
/// <param name="entries"></param>
/// <returns></returns>
public void ConvertCiscoCallHistoryToGeneric(List<CiscoCallHistory.Entry> entries)
{
/// <summary>
/// Event that is raised when the recent calls list has changed
/// </summary>
public event EventHandler<EventArgs> RecentCallsListHasChanged;
var genericEntries = new List<CallHistoryEntry>();
/// <summary>
/// Gets or sets the RecentCalls
/// </summary>
public List<CallHistoryEntry> RecentCalls { get; private set; }
/// <summary>
/// Item that gets added to the list when there are no recent calls in history
/// </summary>
CallHistoryEntry ListEmptyEntry;
/// <summary>
/// Initializes a new instance of the CodecCallHistory class
/// </summary>
public CodecCallHistory()
foreach (CiscoCallHistory.Entry entry in entries)
{
ListEmptyEntry = new CallHistoryEntry() { Name = "No Recent Calls" };
RecentCalls = new List<CallHistoryEntry>();
RecentCalls.Add(ListEmptyEntry);
}
void OnRecentCallsListChange()
{
var handler = RecentCallsListHasChanged;
if (handler != null)
genericEntries.Add(new CallHistoryEntry()
{
handler(this, new EventArgs());
}
Name = entry.DisplayName.Value,
Number = entry.CallbackNumber.Value,
StartTime = entry.LastOccurrenceStartTime.Value,
OccurrenceHistoryId = entry.LastOccurrenceHistoryId.Value,
OccurrenceType = ConvertToOccurenceTypeEnum(entry.OccurrenceType.Value)
});
}
/// <summary>
/// RemoveEntry method
/// </summary>
public void RemoveEntry(CallHistoryEntry entry)
// Check if list is empty and if so, add an item to display No Recent Calls
if(genericEntries.Count == 0)
genericEntries.Add(ListEmptyEntry);
RecentCalls = genericEntries;
OnRecentCallsListChange();
}
/// <summary>
/// Takes the Cisco occurence type and converts it to the matching enum
/// </summary>
/// <param name="s"></param>
public eCodecOccurrenceType ConvertToOccurenceTypeEnum(string s)
{
switch (s)
{
RecentCalls.Remove(entry);
OnRecentCallsListChange();
}
/// <summary>
/// Represents a CallHistoryEntry
/// </summary>
public class CallHistoryEntry : CodecActiveCallItem
{
/// <summary>
/// Gets or sets the StartTime
/// </summary>
[JsonConverter(typeof(IsoDateTimeConverter))]
[JsonProperty("startTime")]
public DateTime StartTime { get; set; }
/// <summary>
/// Gets or sets the occurrence type for this call history entry
/// </summary>
[JsonConverter(typeof(StringEnumConverter))]
[JsonProperty("occurrenceType")]
public eCodecOccurrenceType OccurrenceType { get; set; }
/// <summary>
/// Gets or sets the occurrence history identifier
/// </summary>
[JsonProperty("occurrenceHistoryId")]
public string OccurrenceHistoryId { get; set; }
}
/// <summary>
/// Converts a list of call history entries returned by a Cisco codec to the generic list type
/// </summary>
/// <param name="entries"></param>
/// <returns></returns>
/// <summary>
/// ConvertCiscoCallHistoryToGeneric method
/// </summary>
public void ConvertCiscoCallHistoryToGeneric(List<CiscoCallHistory.Entry> entries)
{
var genericEntries = new List<CallHistoryEntry>();
foreach (CiscoCallHistory.Entry entry in entries)
{
genericEntries.Add(new CallHistoryEntry()
case "Placed":
{
Name = entry.DisplayName.Value,
Number = entry.CallbackNumber.Value,
StartTime = entry.LastOccurrenceStartTime.Value,
OccurrenceHistoryId = entry.LastOccurrenceHistoryId.Value,
OccurrenceType = ConvertToOccurenceTypeEnum(entry.OccurrenceType.Value)
});
}
// Check if list is empty and if so, add an item to display No Recent Calls
if (genericEntries.Count == 0)
genericEntries.Add(ListEmptyEntry);
RecentCalls = genericEntries;
OnRecentCallsListChange();
}
/// <summary>
/// Takes the Cisco occurence type and converts it to the matching enum
/// </summary>
/// <param name="s"></param>
/// <summary>
/// ConvertToOccurenceTypeEnum method
/// </summary>
public eCodecOccurrenceType ConvertToOccurenceTypeEnum(string s)
{
switch (s)
{
case "Placed":
{
return eCodecOccurrenceType.Placed;
}
case "Received":
{
return eCodecOccurrenceType.Received;
}
case "NoAnswer":
{
return eCodecOccurrenceType.NoAnswer;
}
default:
return eCodecOccurrenceType.Unknown;
}
return eCodecOccurrenceType.Placed;
}
case "Received":
{
return eCodecOccurrenceType.Received;
}
case "NoAnswer":
{
return eCodecOccurrenceType.NoAnswer;
}
default:
return eCodecOccurrenceType.Unknown;
}
}
}

52
src/PepperDash.Essentials.Devices.Common/Codec/iHasContentSharing.cs
View file

@ -1,37 +1,35 @@
using PepperDash.Essentials.Core;
namespace PepperDash.Essentials.Devices.Common.Codec;
namespace PepperDash.Essentials.Devices.Common.Codec
/// <summary>
/// Defines the contract for IHasContentSharing
/// </summary>
public interface IHasContentSharing
{
/// <summary>
/// Defines the contract for IHasContentSharing
/// Gets feedback indicating whether content sharing is currently active
/// </summary>
public interface IHasContentSharing
{
/// <summary>
/// Gets feedback indicating whether content sharing is currently active
/// </summary>
BoolFeedback SharingContentIsOnFeedback { get; }
BoolFeedback SharingContentIsOnFeedback { get; }
/// <summary>
/// Gets feedback about the current sharing source
/// </summary>
StringFeedback SharingSourceFeedback { get; }
/// <summary>
/// Gets feedback about the current sharing source
/// </summary>
StringFeedback SharingSourceFeedback { get; }
/// <summary>
/// Gets a value indicating whether content should be automatically shared while in a call
/// </summary>
bool AutoShareContentWhileInCall { get; }
/// <summary>
/// Gets a value indicating whether content should be automatically shared while in a call
/// </summary>
bool AutoShareContentWhileInCall { get; }
/// <summary>
/// Starts content sharing
/// </summary>
void StartSharing();
/// <summary>
/// Starts content sharing
/// </summary>
void StartSharing();
/// <summary>
/// Stops content sharing
/// </summary>
void StopSharing();
}
}
/// <summary>
/// Stops content sharing
/// </summary>
void StopSharing();
}

89
src/PepperDash.Essentials.Devices.Common/Codec/iHasDialer.cs
View file

@ -1,58 +1,57 @@
using System;
namespace PepperDash.Essentials.Devices.Common.Codec
namespace PepperDash.Essentials.Devices.Common.Codec;
/// <summary>
/// Requirements for a device that has dialing capabilities
/// </summary>
public interface IHasDialer
{
// Add requirements for Dialer functionality
/// <summary>
/// Requirements for a device that has dialing capabilities
/// Event that is raised when call status changes
/// </summary>
public interface IHasDialer
{
// Add requirements for Dialer functionality
event EventHandler<CodecCallStatusItemChangeEventArgs> CallStatusChange;
/// <summary>
/// Event that is raised when call status changes
/// </summary>
event EventHandler<CodecCallStatusItemChangeEventArgs> CallStatusChange;
/// <summary>
/// Dials the specified number
/// </summary>
/// <param name="number">The number to dial</param>
void Dial(string number);
/// <summary>
/// Dials the specified number
/// </summary>
/// <param name="number">The number to dial</param>
void Dial(string number);
/// <summary>
/// Ends the specified active call
/// </summary>
/// <param name="activeCall">The active call to end</param>
void EndCall(CodecActiveCallItem activeCall);
/// <summary>
/// Ends the specified active call
/// </summary>
/// <param name="activeCall">The active call to end</param>
void EndCall(CodecActiveCallItem activeCall);
/// <summary>
/// Ends all active calls
/// </summary>
void EndAllCalls();
/// <summary>
/// Ends all active calls
/// </summary>
void EndAllCalls();
/// <summary>
/// Accepts the specified incoming call
/// </summary>
/// <param name="item">The call item to accept</param>
void AcceptCall(CodecActiveCallItem item);
/// <summary>
/// Accepts the specified incoming call
/// </summary>
/// <param name="item">The call item to accept</param>
void AcceptCall(CodecActiveCallItem item);
/// <summary>
/// Rejects the specified incoming call
/// </summary>
/// <param name="item">The call item to reject</param>
void RejectCall(CodecActiveCallItem item);
/// <summary>
/// Rejects the specified incoming call
/// </summary>
/// <param name="item">The call item to reject</param>
void RejectCall(CodecActiveCallItem item);
/// <summary>
/// Sends DTMF digits during a call
/// </summary>
/// <param name="digit">The DTMF digit(s) to send</param>
void SendDtmf(string digit);
/// <summary>
/// Sends DTMF digits during a call
/// </summary>
/// <param name="digit">The DTMF digit(s) to send</param>
void SendDtmf(string digit);
/// <summary>
/// Gets a value indicating whether the device is currently in a call
/// </summary>
bool IsInCall { get; }
}
/// <summary>
/// Gets a value indicating whether the device is currently in a call
/// </summary>
bool IsInCall { get; }
}
}