/// <summary>
/// ger config function
/// </summary>
/// <param name="sender"></param>
/// <param name="msg"></param>
private void getConf(object sender, DataInfo msg)
{
if (msg.Id == CommandEnum.GetConfigCommand)
{
string[] arr = JsonConvert.DeserializeObject <string[]>(msg.Args);
OutputDir = arr[1];
SourceName = arr[2];
LogName = arr[3];
ThumbnailSize = (string)arr[4];
string hanslersToSplit = arr[0];
string[] temp = hanslersToSplit.Split(';');
Handlers.Clear();
foreach (string item in temp)
{
Handlers.Add(item);
}
ifConfUpdate = true;
}
}
public SpectrumNextPortDevice()
{
Handlers.Add(new Spectrum48PortHandler(this));
_memoryPortHandler = new SpectrumP3MemoryPagePortHandler(this);
_extMemoryPortHandler = new SpectrumP3ExtMemoryPagePortHandler(this);
_memoryPortHandler.RomLowSelectionChanged += (sender, args)
=> _extMemoryPortHandler.SelectRomLow = (byte)sender;
_memoryPortHandler.LastSlot3IndexChanged += (sender, args)
=> _extMemoryPortHandler.LastSlot3Index = (int)sender;
Handlers.Add(_memoryPortHandler);
_extMemoryPortHandler.RomHighSelectionChanged += (sender, args)
=> _memoryPortHandler.SelectRomHigh = (byte)sender;
Handlers.Add(_extMemoryPortHandler);
Handlers.Add(new NextRegisterSelectPortHandler(this));
Handlers.Add(new NextRegisterAccessPortHandler(this));
Handlers.Add(new SoundRegisterIndexPortHandler(this));
Handlers.Add(new SoundRegisterValuePortHandler(this));
Handlers.Add(new DivIdeControlPortHandler(this));
}
public SpectrumP3PortDevice()
{
Handlers.Add(new Spectrum48PortHandler(this));
_memoryPortHandler = new SpectrumP3MemoryPagePortHandler(this);
_extMemoryPortHandler = new SpectrumP3ExtMemoryPagePortHandler(this);
_memoryPortHandler.RomLowSelectionChanged += (sender, args)
=> _extMemoryPortHandler.SelectRomLow = (byte)sender;
_memoryPortHandler.LastSlot3IndexChanged += (sender, args)
=> _extMemoryPortHandler.LastSlot3Index = (int)sender;
Handlers.Add(_memoryPortHandler);
_extMemoryPortHandler.RomHighSelectionChanged += (sender, args)
=> _memoryPortHandler.SelectRomHigh = (byte)sender;
Handlers.Add(_extMemoryPortHandler);
Handlers.Add(new SoundRegisterIndexPortHandler(this));
Handlers.Add(new SoundRegisterValuePortHandler(this));
Handlers.Add(new SpectrumP3FloatingPointBusPortHandler(this));
Handlers.Add(new SpectrumP3FloppyStatusPortHandler(this));
Handlers.Add(new SpectrumP3FloppyCommandPortHandler(this));
}
public bool Handle(byte[] firstPacket, int length, Socket socket, object state)
{
if (socket.ProtocolType != ProtocolType.Tcp)
{
return(false);
}
if (length < 2 || firstPacket[0] != 5)
{
return(false);
}
socket.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.NoDelay, true);
TCPHandler handler = new TCPHandler(this);
handler.connection = socket;
handler.relay = this;
handler.Start(firstPacket, length);
IList <TCPHandler> handlersToClose = new List <TCPHandler>();
lock (Handlers)
{
Handlers.Add(handler);
DateTime now = DateTime.Now;
if (now - _lastSweepTime > TimeSpan.FromSeconds(1))
{
_lastSweepTime = now;
foreach (TCPHandler handler1 in Handlers)
{
if (now - handler1.lastActivity > TimeSpan.FromSeconds(900))
{
handlersToClose.Add(handler1);
}
}
}
}
foreach (TCPHandler handler1 in handlersToClose)
{
Logging.Debug("Closing timed out TCP connection.");
handler1.Close();
}
return(true);
}
/// <summary>
/// receiving a configuration.
/// </summary>
/// <param name="sender">the sender of the massage</param>
/// <param name="msg">the configurations that reseived </param>
public void OnConfigRecieved(object sender, MessageEventArgs msg)
{
// Parsing the message
string message = msg.Message;
JObject obj = JObject.Parse(message);
// Updating the configuration field
OutputDir = obj["OutputDir"].ToString();
SourceName = obj["SourceName"].ToString();
LogName = obj["LogName"].ToString();
int.TryParse(obj["ThumbnailSize"].ToString(), out int thumbnailSize);
ThumbnailSize = thumbnailSize;
// Parsing the handlers Paths
string[] handlerPaths = JsonConvert.DeserializeObject <string[]>(obj["HandlersPaths"].ToString());
// Adding each handler to the Handlers list
foreach (string path in handlerPaths)
{
Handlers.Add(path);
}
}
private static bool DeserializeHandlers(GenericReader reader)
{
var list = reader.ReadBlockArray(() => reader.ReadTypeCreate <BaseTrashHandler>(reader));
list.ForEach(
h =>
{
if (!Handlers.ContainsKey(h.UID))
{
Handlers.Add(h.UID, h);
}
else
{
Handlers[h.UID] = h;
}
});
InternalHandlerSort();
return(true);
}
public MucRoomMember(MucRoom room, Jid memberJid, Jid realJid, XmppStream stream, XmppHandlerContext context)
{
if (room == null)
{
throw new ArgumentNullException("room");
}
if (memberJid == null)
{
throw new ArgumentNullException("memberJid");
}
if (realJid == null)
{
throw new ArgumentNullException("realJid");
}
if (context == null)
{
throw new ArgumentNullException("sender");
}
this.room = room;
this.stream = stream;
this.context = context;
this.sender = context.Sender;
//Register disconect
context.SessionManager.SessionUnavailable += SessionManager_SessionUnavailable;
ParentService = room;
RealJid = realJid;
Jid = memberJid;
Name = memberJid.Resource;
presenceType = PresenceType.unavailable;
//Create handler
lock (Handlers)
{
Handlers.Add(new MucRoomMemberStanzaHandler(this));
Handlers.Add(new MucRoomMemberDiscoHandler(Jid, RealJid));
}
DiscoInfo.AddIdentity(new DiscoIdentity("text", Name, "member"));
DiscoInfo.AddFeature(new DiscoFeature(Core.protocol.Uri.DISCO_INFO));
DiscoInfo.AddFeature(new DiscoFeature(Core.protocol.Uri.DISCO_ITEMS));
}
/// <summary>
/// Recieves command from server.
/// </summary>
/// <param name="commandRead">The command recieved arguments.</param>
private void ServerCommandRecieved(CommandRecievedEventArgs commandRead)
{
//GetConfigCommand recieved. We set the correct properties and add the handlers to the Handlers ObservableCollection.
if (commandRead != null && commandRead.CommandID == (int)CommandEnum.GetConfigCommand)
{
OutputDir = commandRead.Args[0];
SourceName = commandRead.Args[1];
LogName = commandRead.Args[2];
ThumbnailSize = commandRead.Args[3];
Object thisLock = new Object();
BindingOperations.EnableCollectionSynchronization(Handlers, thisLock);
if (commandRead.Args[4] != "")
{
string[] handlers = commandRead.Args[4].Split(';');
foreach (string handler in handlers)
{
if (handler != "")
{
App.Current.Dispatcher.Invoke((Action) delegate
{
Handlers.Add(handler);
});
}
}
}
}
//CloseCommand recieved. We remove the given handler from the Handlers ObservableCollection.
else if (commandRead != null && commandRead.CommandID == (int)CommandEnum.CloseCommand)
{
Object thisLock = new Object();
BindingOperations.EnableCollectionSynchronization(Handlers, thisLock);
if (Handlers.Contains(commandRead.Args[0]))
{
App.Current.Dispatcher.Invoke((Action) delegate
{
Handlers.Remove(commandRead.Args[0]);
});
}
}
}
public void ProcessMessage(object sender, CommandMessageEventArgs e)
{
//Extract the message from the EventArgs
CommandMessage msg = e.Message;
switch (msg.Type)
{
//Checking if the message is interesting to the Settings
case CommandEnum.AddHandler:
foreach (string handler in msg.Handlers)
{
Handlers.Add(handler);
}
NotifyPropertyChanged("Handlers");
break;
case CommandEnum.RemoveHandler:
foreach (string handler in msg.Handlers)
{
Handlers.Remove(handler);
}
NotifyPropertyChanged("Handlers");
break;
case CommandEnum.ConfigMessage:
OutputDir = msg.OutputDir;
SourceName = msg.LogSource;
LogName = msg.LogName;
ThumSize = msg.ThumbSize.ToString();
foreach (string handler in msg.Handlers)
{
Handlers.Add(handler);
}
NotifyPropertyChanged("Handlers");
break;
default:
break;
}
}
/// <summary>
/// This method initialize the config involves members
/// </summary>
/// <param name="settings"></param>
public void InitializeConfig(string[] settings)
{
try
{
Application.Current.Dispatcher.Invoke(new Action(() =>
{
OutputDirectory = settings[0];
SourceName = settings[1];
LogName = settings[2];
ThumbnailSize = int.Parse(settings[3]);
for (int i = 4; i < settings.Length; i++)
{
Handlers.Add(settings[i]);
}
}));
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
protected void When(
Func <Exception, bool> condition,
Func <ResilientOperation, Exception, Task> handler)
{
Handlers.Add(async(op, ex) =>
{
op.Result = HandlerResult.Unhandled;
if (condition(ex))
{
await handler(op, ex).ConfigureAwait(false);
if (op.Result == HandlerResult.Handled)
{
op.Handler.AttemptsExhausted++;
op.Total.AttemptsExhausted++;
}
}
return(op.Result);
});
}
/// <summary>
/// Updating our settings configuration
/// </summary>
/// <param name="sender"> Event sender</param>
/// <param name="msg"> The message recived from server</param>
public void SettingsConfigRecieved(object sender, MessageEventArgs msg)
{
// Clearing our list each refresh
Handlers.Clear();
// Parsing our message
string message = msg.Message;
JObject obj = JObject.Parse(message);
// Updating each configuratoin field
Output = obj["Output"].ToString();
SourceName = obj["SourceName"].ToString();
LogName = obj["LogName"].ToString();
int.TryParse(obj["thumbnailSize"].ToString(), out int thumbnailSize);
ThumbnailSize = thumbnailSize;
// Parsing our handlerPaths
string[] handlerPaths = JsonConvert.DeserializeObject <string[]>(obj["handlersPaths"].ToString());
// Adding each one to our observable collection list
foreach (string str in handlerPaths)
{
Handlers.Add(str);
}
}
public void InitializeConfig(string[] settings)
{
try
{
OutputDirectory = settings[0];
SourceName = settings[1];
LogName = settings[2];
ThumbnailSize = int.Parse(settings[3]);
for (int i = 4; i < settings.Length; i++)
{
if (settings[i] != null)
{
Handlers.Add(settings[i]);
}
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
/// <summary>
/// construct a HttpRequestHandler with the path to handle
/// </summary>
/// <param name="name">the name of the handler</param>
/// <param name="type">the type (data type) the handler handles</param>
/// <param name="path">the path in url must start with "/"</param>
/// <param name="credentials">user credentials in the format user:password and separated by comma</param>
protected HttpServiceRequestHandler(string name, string type, string path, string credentials)
{
Name = name;
Type = type;
Path = path;
if (Handlers.ContainsKey(path))
{
Handlers[path] = this;
}
else
{
Handlers.Add(path, this);
}
if (!string.IsNullOrEmpty(credentials))
{
_encodedCredentials = new HashSet <string>();
string[] parts = credentials.Split(CommaDelimiter);
foreach (string part in parts)
{
_encodedCredentials.Add("Basic " + EncodeCredential(part.Trim()));
}
}
}
public Receiver()
{
var type = GetType();
foreach (var method in type.GetMethods(BindingFlags.Instance | BindingFlags.NonPublic)
.Where(p => p.ReturnType == typeof(void)))
{
var attribute = method.GetCustomAttribute <MessageHandlerAttribute>();
if (attribute != null)
{
if (Handlers.ContainsKey(attribute.Name))
{
throw new ArgumentException($"Message '{attribute.Name}' already registered.");
}
var handler = method.CreateDelegate(
Expression.GetDelegateType(method.GetParameters()
.Select(p => p.ParameterType).Concat(new[] { method.ReturnType }).ToArray()
), this);
Handlers.Add(attribute.Name, handler);
}
}
}
public IAsyncEventHandler CreateHandler(Func <TArg, Task> handler,
[CallerFilePath] string callerFile = null, [CallerLineNumber] int line = 0)
{
if (handler == null)
{
throw new ArgumentNullException(nameof(handler));
}
lock (Handlers)
{
RemoveHandler(handler);
var result = new AsyncEventTaskHandler <TArg>
{
Action = handler,
Event = this,
Caller = Debugger.IsAttached ? $"{callerFile}:{line}" : string.Empty
};
Handlers.Add(result);
return(result);
}
}
/// <summary>
/// UpdateConfigurations function.
/// updates app config params.
/// </summary>
/// <param name="responseObj">the info came from srv</param>
private void UpdateConfigurations(CommandRecievedEventArgs responseObj)
{
try
{
OutputDirectory = responseObj.Args[0];
SourceName = responseObj.Args[1];
LogName = responseObj.Args[2];
int num;
int.TryParse(responseObj.Args[3], out num);
ThumbnailSize = num;
string[] handlers = responseObj.Args[4].Split(';');
foreach (string handler in handlers)
{
if (!Handlers.Contains(handler))
{
Handlers.Add(handler);
}
}
}
catch (Exception ex)
{
}
}
public override void Configure(IDictionary <string, string> properties)
{
DiscoInfo.AddIdentity(new DiscoIdentity("server", Name, "im"));
Handlers.Add(new ClientNamespaceHandler());
Handlers.Add(new AuthDigestMD5Handler());
Handlers.Add(new AuthTMTokenHandler());
Handlers.Add(new BindSessionHandler());
Handlers.Add(new RosterHandler());
Handlers.Add(new VCardHandler());
Handlers.Add(new VerTimePingHandler());
Handlers.Add(new PrivateHandler());
Handlers.Add(new PresenceHandler());
Handlers.Add(new MessageHandler());
Handlers.Add(new MessageArchiveHandler());
Handlers.Add(new LastHandler());
Handlers.Add(new RegisterHandler());
Handlers.Add(new TransferHandler());
Handlers.Add(new CommandHandler());
Handlers.Add(new OfflineProvider(Jid));
Handlers.Add(new DiscoHandler(Jid));
messageAnnounceHandler = new MessageAnnounceHandler();
}
public override bool Handle(byte[] firstPacket, int length, SocketProxy socket, object state)
{
if (NotCompatible(firstPacket, length, socket))
{
return(false);
}
socket.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.NoDelay, true);
var handler = TCPHandlerFactory(_controller, _config, this, socket);
var handlersToClose = Enumerable.Empty <ITCPHandler>();
lock (Handlers)
{
Handlers.Add(handler);
var now = DateTime.Now;
if (NeedSweepTimeoutHandlers(now))
{
_lastSweepTime = now;
handlersToClose = GetTimeoutHandlersList(now);
}
}
foreach (var timeoutHandler in handlersToClose)
{
Logging.Debug("Closing timed out TCP connection.");
timeoutHandler.Close();
}
/*
* Start after we put it into Handlers set. Otherwise if it failed in handler.Start()
* then it will call handler.Close() before we add it into the set.
* Then the handler will never release until the next Handle call. Sometimes it will
* cause odd problems (especially during memory profiling).
*/
handler.Start(firstPacket, length);
return(true);
}
/// <summary>
/// Contains features, properties and events regarding the charging bays and the devices inserted into the bays.
/// </summary>
public Chg4NBaysHandler(SscCommon common)
: base(common)
{
for (int i = 0; i < _bays.Length; i++)
{
_bays[i] = new Chg4NBay();
}
Handlers.Add("active", HandleActive);
Handlers.Add("serial", HandleSerial);
Handlers.Add("charging", HandleCharging);
Handlers.Add("bat_gauge", HandleBatteryGauge);
Handlers.Add("bat_health", HandleBatteryHealth);
Handlers.Add("bat_timetofull", HandleBatteryTimeToFull);
Handlers.Add("device_type", HandleDeviceType);
Subscribe(BaseProperty, "active");
Subscribe(BaseProperty, "serial");
Subscribe(BaseProperty, "charging");
Subscribe(BaseProperty, "bat_gauge");
Subscribe(BaseProperty, "bat_timetofull");
Subscribe(BaseProperty, "bat_health");
Subscribe(BaseProperty, "device_type");
}
public virtual void WireDefaultHandlers()
{
// Insert pre-handlers in the reverse order.
Handlers.Insert(0, new RequestFormatHandler());
Handlers.Insert(0, new RouteResolutionHandler());
Handlers.Insert(0, new HttpStatusHandler());
Handlers.Insert(0, new ResponseFormatHandler());
#if DEBUG
Handlers.Insert(0, new TraceHandler());
#endif
Handlers.Insert(0, new ErrorHandler());
// Buffered stream handler has to be after error handling so that buffered streams can be copied back.
if (UseBufferedResponse || UseBufferedRequest)
{
Handlers.Insert(0, new BufferedStreamHandler());
}
Handlers.Insert(0, new ThrottleHandler());
// Add the final handlers after the user handlers.
Handlers.Add(new RouteInvocationHandler());
isDefaultHandlerListWired = true;
}
public void Add <TEvent, TEventHandler>()
where TEvent : Event
where TEventHandler : IEventHandler <TEvent>
{
var eventType = typeof(TEvent);
EventTypes.Add(eventType);
var handlerType = typeof(TEventHandler);
var eventName = eventType.Name;
if (Handlers.ContainsKey(eventName))
{
var handler = Handlers[eventName];
var isRegistered = handler.Types.Any(s => s.GetType() == handlerType);
Ensure.That <ArgumentException>(isRegistered, $"Handler Type {handlerType.Name} already is registered for '{eventName}'");
}
var newType = EventTypes.New();
newType.Add(handlerType);
Handlers.Add(eventName, newType);
}
public void LoadHandlerFromType(Type type)
{
try
{
if (!typeof(AttributeHandler).IsAssignableFrom(type))
{
return;
}
if (type.IsAbstract)
{
return;
}
var handlerobject = Activator.CreateInstance(type);
if (!(handlerobject is AttributeHandler handler))
{
return;
}
if (string.IsNullOrWhiteSpace(handler.Name))
{
return;
}
if (Handlers.Any(x => x.Name.ToLower() == handler.Name.ToLower()))
{
return;
}
Handlers.Add(handler);
handler.Init();
}
catch (Exception ex)
{
Logger.Get.Debug($"Synapse-Objects: Type {type?.Name} could not be loaded as AttributeHandler\n{ex}");
}
}
/// <summary>
/// Contains features, properties and events regarding meters, such as azimuth, elevation and input peak level.
/// </summary>
public Tcc2MeterHandler(SscCommon common)
: base(common)
{
Handlers.Add("beam", HandleBeam);
Handlers.Add("in1", HandleIn);
}
protected void given_handler <T>()
{
Handlers = Handlers ?? new List <IType>();
Handlers.Add(TypeSystem.FromClr <T>());
}
public Spectrum48PortDevice()
{
IPortHandler handler = new Spectrum48PortHandler(this);
Handlers.Add(handler);
}
public Spectrum48PortDevice()
{
Handlers.Add(new Spectrum48PortHandler(this));
Handlers.Add(new KempstonJoystickPortHandler(this));
}
public void RegisterHandler(RightHandler <RightOption> handler)
{
Handlers.Add(handler);
}
/// <summary>
/// add handler to the list.
/// </summary>
/// <param name="handler">handler</param>
public void addHandler(string handler)
{
Handlers.Add(handler);
}
static InstrumentDetector()
{
Handlers.Add(InstrumentTypeEnum.Guitar, Guitar);
Handlers.Add(InstrumentTypeEnum.PureSound, PureSound);
}
