src/main/java/org/lwes/listener/DatagramEventListener.java

   1 package org.lwes.listener;
   2
   3 import java.net.InetAddress;
   4
   5 import org.lwes.EventSystemException;
   6
   7 /**
   8  * This is an event listener that handles UDP packets.  Automatically
   9  * detects multicast addresses and joins those groups.
  10  *
  11  * Sample code that prints multicast events to stdout:
  12  * <pre>
  13  * EventHandler myHandler = new EventPrintingHandler();
  14  * InetAddress address = InetAddress.getByName("224.0.0.69");
  15  *
  16  * DatagramEventListener listener = new DatagramEventListener();
  17  * listener.setAddress(address);
  18  * listener.setPort(9191);
  19  * listener.addHandler(myHandler);
  20  * listener.initialize();
  21  * </pre>
  22  *
  23  * @author Michael P. Lum
  24  */
  25 public class DatagramEventListener extends ThreadedEventListener {
  26         /* the enqueuer to use to acquire multicast packets */
  27         private DatagramEnqueuer enqueuer = new DatagramEnqueuer();
  28
  29         /* the dequeuer to use to handle packets */
  30         private DatagramDequeuer dequeuer = new DatagramDequeuer();
  31
  32         /**
  33          * Default constructor.
  34          */
  35         public DatagramEventListener() {
  36         }
  37
  38         /**
  39          * Gets the address to use for this listener
  40          * @return the address
  41          */
  42         public InetAddress getAddress() {
  43                 if(enqueuer == null) return null;
  44                 return enqueuer.getAddress();
  45         }
  46
  47         /**
  48          * Sets the address to use for this listener
  49          * @param address the address
  50          */
  51         public void setAddress(InetAddress address) {
  52                 if(enqueuer != null) {
  53                         enqueuer.setAddress(address);
  54                 }
  55         }
  56
  57         /**
  58          * Gets the port to use for this listener
  59          * @return the port
  60          */
  61         public int getPort() {
  62                 if(enqueuer == null) return 0;
  63                 return enqueuer.getPort();
  64         }
  65
  66         /**
  67          * Sets the port to use for this listener
  68          * @param port the port
  69          */
  70         public void setPort(int port) {
  71                 if(enqueuer != null) {
  72                         enqueuer.setPort(port);
  73                 }
  74         }
  75
  76         /**
  77          * Get the interface to use for this listener
  78          * @return the interface
  79          */
  80         public InetAddress getInterface() {
  81                 if(enqueuer == null) return null;
  82                 return enqueuer.getInterface();
  83         }
  84
  85         /**
  86          * Sets the interface to use for this listener
  87          * @param iface the interface
  88          */
  89         public void setInterface(InetAddress iface) {
  90                 if(enqueuer != null) {
  91                         enqueuer.setInterface(iface);
  92                 }
  93         }
  94
  95         /**
  96          * Get the TTL to use for this listener.  Only applies to
  97          * multicast listeners.  Typically this does not need to be changed.
  98          * @return the interface
  99          */
 100         public int getTimeToLive() {
 101                 if(enqueuer == null) return 0;
 102                 return enqueuer.getTimeToLive();
 103         }
 104
 105         /**
 106          * Sets the TTL to use for this listener.  Only applies to multicast listeners.
 107          * Typically this does not need to be changed.
 108          * @param ttl the TTL value
 109          */
 110         public void setTimeToLive(int ttl) {
 111                 if(enqueuer != null) {
 112                         enqueuer.setTimeToLive(ttl);
 113                 }
 114         }
 115
 116         /**
 117          * Returns the max number of threads allowed by the system.
 118          * @return the allowed threads
 119          */
 120         public int getMaxThreads() {
 121                 if(dequeuer == null) return 0;
 122                 return dequeuer.getMaxThreads();
 123         }
 124
 125         /**
 126          * Sets the max number of threads allowed by the system.
 127          * @param threads the max number of threads
 128          */
 129         public void setMaxThreads(int threads) {
 130                 if(dequeuer != null) {
 131                         dequeuer.setMaxThreads(threads);
 132                 }
 133         }
 134
 135         /**
 136          * Adds an event handler to this listener.  This has a callback that will be invoked
 137          * for every event coming through the system.
 138          * @param handler the EventHandler to add
 139          */
 140         public void addHandler(EventHandler handler) {
 141                 if(dequeuer != null) {
 142                         dequeuer.addHandler(handler);
 143                 }
 144         }
 145
 146         /**
 147          * Removes an event handler from the system.  This causes the event handler to no longer
 148          * receive events coming through the system.
 149          * @param handler the EventHandler to remove
 150          */
 151         public void removeHandler(EventHandler handler) {
 152                 if(dequeuer != null) {
 153                         dequeuer.removeHandler(handler);
 154                 }
 155         }
 156
 157         /**
 158          * Initializes the listener.
 159          * @exception EventSystemException thrown if there is a problem initializing the listener
 160          */
 161         public void initialize() throws EventSystemException {
 162                 this.setEnqueuer(enqueuer);
 163                 this.setDequeuer(dequeuer);
 164                 super.initialize();
 165         }
 166
 167 }