public Boolean removeListener(ContextEventListener listener)
{
lock (listeners)
{
return(listeners.Remove(listener));
}
}
public Boolean addEventListener(String name, ContextEventListener contextEventListener,
Boolean sendRemoteCommand)
{
try
{
init();
var ed = getEventData(name);
if (ed == null)
{
throw new ContextException(Cres.get().getString("conEventNotFound") + name);
}
if (sendRemoteCommand)
{
addRemoteListener(ed.getDefinition().getName(), contextEventListener);
}
return(base.addEventListener(name, contextEventListener));
}
catch (Exception ex)
{
var msg = String.Format(Cres.get().getString("conErrAddingListener"), name, this.getPath());
throw new InvalidOperationException(msg + ": " + ex.Message, ex);
}
}
public Boolean removeEventListener(String name, ContextEventListener contextEventListener,
Boolean sendRemoteCommand)
{
try
{
init();
Log.CONTEXT_EVENTS.debug("Removing listener for event '" + name + "' from context '" + this.getPath() + "'");
var res = base.removeEventListener(name, contextEventListener);
var ed = getEventData(name);
if (sendRemoteCommand && ed != null && ed.getListeners().Count == 0)
{
var hashCode = contextEventListener.getListenerCode();
if (!notManageRemoteListenersBoolean)
{
this.controller.sendCommandAndCheckReplyCode(ClientCommandUtils.removeEventListenerOperation(this.getPath(), name, hashCode));
}
}
return(res);
}
catch (Exception ex)
{
var msg = String.Format(Cres.get().getString("conErrRemovingListener"), name, this.getPath());
throw new InvalidOperationException(msg + ": " + ex.Message, ex);
}
}
public Boolean addListener(ContextEventListener listener)
{
lock (listeners)
{
return(listeners.Add(listener));
}
}
private void addEventListener(String context, String eventString, ContextEventListener listener, Boolean mask)
{
var con = get(context, listener.getCallerController());
if (con != null)
{
var events = EventUtils.getEvents(con, eventString, listener.getCallerController());
foreach (var ed in events)
{
addListenerToContext(con, ed.getName(), listener, mask);
}
}
else
{
if (!mask)
{
var eel = getListeners(context, eventString);
if (!eel.Contains(listener))
{
eel.Add(listener);
}
}
}
}
protected void addListenerToContext(Context con, String eventString, ContextEventListener listener, Boolean mask)
{
var ed = con.getEventDefinition(eventString, listener.getCallerController());
if (ed != null)
{
con.addEventListener(eventString, listener);
}
}
protected AbstractClientController(StreamWrapper wrapper, ContextManager contextManager)
{
this.contextManager = contextManager;
this.streamWrapper = wrapper; //Stream.Synchronized(aStream);
commandBuffer = new CommandBuffer(wrapper, Command.START_CHAR, Command.END_CHAR);
defaultEventListener = new ForwardingEventListener(this, null);
}
public virtual void addMaskEventListener(String mask, String eventString, ContextEventListener listener)
{
var contexts = ContextUtils.expandContextMaskToPaths(mask, this, listener.getCallerController());
foreach (var con in contexts)
{
addEventListener(con, eventString, listener, true);
}
getMaskListeners(mask, eventString).Add(listener);
}
private void addRemoteListener(String ename, ContextEventListener contextEventListener)
{
var hashCode = contextEventListener.getListenerCode();
if (hashCode == null && AUTO_LISTENED_EVENTS.Contains(ename))
{
return;
}
if (!notManageRemoteListenersBoolean)
{
controller.sendCommandAndCheckReplyCode(ClientCommandUtils.addEventListenerOperation(this.getPath(), ename, hashCode));
}
}
public virtual void removeMaskEventListener(String mask, String eventString, ContextEventListener listener)
{
var contexts = ContextUtils.expandContextMaskToContexts(mask, this, listener.getCallerController());
foreach (var con in contexts)
{
var events = EventUtils.getEvents(con, eventString, listener.getCallerController());
foreach (var ed in events)
{
removeEventListener(con.getPath(), ed.getName(), listener, true);
}
}
getMaskListeners(mask, eventString).Remove(listener);
}
private void sendRemoveListener(String context, String eventString, ContextEventListener listener)
{
try
{
getController().sendCommandAndCheckReplyCode(ClientCommandUtils.removeEventListenerOperation(context,
eventString,
listener.
getListenerCode
()));
}
catch (Exception ex)
{
var msg = String.Format(Cres.get().getString("conErrRemovingListener"), eventString, context);
throw new InvalidOperationException(msg + ": " + ex.Message, ex);
}
}
private void removeEventListener(String context, String eventString, ContextEventListener listener, Boolean mask)
{
var con = get(context, listener.getCallerController());
if (con != null)
{
if (con.getEventDefinition(eventString) != null)
{
removeListenerFromContext(con, eventString, listener, mask);
}
}
else
{
if (!mask)
{
var eel = getListeners(context, eventString);
if (eel != null)
{
eel.Remove(listener);
}
}
}
}
public override Boolean controllerShouldHandle(Event ev, ContextEventListener listener)
{
return(true);
}
public abstract Boolean controllerShouldHandle(Event ev, ContextEventListener listener);
private void removeMaskListener(String context, String name, ContextEventListener cel)
{
contextManager.removeMaskEventListener(context, name, cel);
eventListeners.Remove(new EntityReference(context, name));
}
protected Boolean addNormalListener(String context, String name, ContextEventListener cel)
{
var con = contextManager.get(context, callerController);
return(con != null && con.addEventListener(name, cel));
}
private void addMaskListener(String context, String name, ContextEventListener cel)
{
contextManager.addMaskEventListener(context, name, cel);
eventListeners.Add(new EntityReference(context, name), cel);
}
protected virtual void removeListenerFromContext(Context con, String eventString, ContextEventListener listener,
Boolean mask)
{
con.removeEventListener(eventString, listener);
}
public override Boolean removeEventListener(String name, ContextEventListener contextEventListener)
{
return(removeEventListener(name, contextEventListener, true));
}
public override void removeMaskEventListener(String mask, String eventString, ContextEventListener listener)
{
base.removeMaskEventListener(mask, eventString, listener);
sendRemoveListener(mask, eventString, listener);
}
public override void addMaskEventListener(String mask, String eventString, ContextEventListener listener)
{
base.addMaskEventListener(mask, eventString, listener);
sendAddListener(mask, eventString, listener);
}
protected void removeListenerFromContext(RemoteDeviceContextProxy <TDevice> con, String eventString,
ContextEventListener listener, Boolean mask)
{
con.removeEventListener(eventString, listener, !mask);
// Don't send remote command if adding as mask listener
}
