src/javax/jmdns/impl/ListenerStatus.java

/**
 *
 */
package javax.jmdns.impl;

import java.util.EventListener;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.logging.Logger;

import javax.jmdns.JmDNS;
import javax.jmdns.ServiceEvent;
import javax.jmdns.ServiceInfo;
import javax.jmdns.ServiceListener;
import javax.jmdns.ServiceTypeListener;

/**
 * This class track the status of listener.<br/>
 * The main purpose of this class is to collapse consecutive events so that we can guarantee the correct call back sequence.
 * 
 * @param <T>
 *            listener type
 */
public class ListenerStatus<T extends EventListener> {

    public static class ServiceListenerStatus extends ListenerStatus<ServiceListener> {
        private static Logger                            logger = Logger.getLogger(ServiceListenerStatus.class.getName());

        private final ConcurrentMap<String, ServiceInfo> _addedServices;

        /**
         * @param listener
         *            listener being tracked.
         * @param synch
         *            true if that listener can be called asynchronously
         */
        public ServiceListenerStatus(ServiceListener listener, boolean synch) {
            super(listener, synch);
            _addedServices = new ConcurrentHashMap<String, ServiceInfo>(32);
        }

        /**
         * A service has been added.<br/>
         * <b>Note:</b>This event is only the service added event. The service info associated with this event does not include resolution information.<br/>
         * To get the full resolved information you need to listen to {@link #serviceResolved(ServiceEvent)} or call {@link JmDNS#getServiceInfo(String, String, long)}
         * 
         * <pre>
         *  ServiceInfo info = event.getDNS().getServiceInfo(event.getType(), event.getName())
         * </pre>
         * <p>
         * Please note that service resolution may take a few second to resolve.
         * </p>
         * 
         * @param event
         *            The ServiceEvent providing the name and fully qualified type of the service.
         */
        void serviceAdded(ServiceEvent event) {
            String qualifiedName = event.getName() + "." + event.getType();
            if (null == _addedServices.putIfAbsent(qualifiedName, event.getInfo().clone())) {
                this.getListener().serviceAdded(event);
                ServiceInfo info = event.getInfo();
                if ((info != null) && (info.hasData())) {
                    this.getListener().serviceResolved(event);
                }
            } else {
                logger.finer("Service Added called for a service already added: " + event);
            }
        }

        /**
         * A service has been removed.
         * 
         * @param event
         *            The ServiceEvent providing the name and fully qualified type of the service.
         */
        void serviceRemoved(ServiceEvent event) {
            String qualifiedName = event.getName() + "." + event.getType();
            if (_addedServices.remove(qualifiedName, _addedServices.get(qualifiedName))) {
                this.getListener().serviceRemoved(event);
            } else {
                logger.finer("Service Removed called for a service already removed: " + event);
            }
        }

        /**
         * A service has been resolved. Its details are now available in the ServiceInfo record.<br/>
         * <b>Note:</b>This call back will never be called if the service does not resolve.<br/>
         * 
         * @param event
         *            The ServiceEvent providing the name, the fully qualified type of the service, and the service info record.
         */
        synchronized void serviceResolved(ServiceEvent event) {
            ServiceInfo info = event.getInfo();
            if ((info != null) && (info.hasData())) {
                String qualifiedName = event.getName() + "." + event.getType();
                ServiceInfo previousServiceInfo = _addedServices.get(qualifiedName);
                if (!_sameInfo(info, previousServiceInfo)) {
                    if (null == previousServiceInfo) {
                        if (null == _addedServices.putIfAbsent(qualifiedName, info.clone())) {
                            this.getListener().serviceResolved(event);
                        }
                    } else {
                        if (_addedServices.replace(qualifiedName, previousServiceInfo, info.clone())) {
                            this.getListener().serviceResolved(event);
                        }
                    }
                } else {
                    logger.finer("Service Resolved called for a service already resolved: " + event);
                }
            } else {
                logger.warning("Service Resolved called for an unresolved event: " + event);

            }
        }

        private static final boolean _sameInfo(ServiceInfo info, ServiceInfo lastInfo) {
            if (info == null) return false;
            if (lastInfo == null) return false;
            if (!info.equals(lastInfo)) return false;
            byte[] text = info.getTextBytes();
            byte[] lastText = lastInfo.getTextBytes();
            if (text.length != lastText.length) return false;
            for (int i = 0; i < text.length; i++) {
                if (text[i] != lastText[i]) return false;
            }
            return true;
        }

        /*
         * (non-Javadoc)
         * @see java.lang.Object#toString()
         */
        @Override
        public String toString() {
            StringBuilder aLog = new StringBuilder(2048);
            aLog.append("[Status for ");
            aLog.append(this.getListener().toString());
            if (_addedServices.isEmpty()) {
                aLog.append(" no type event ");
            } else {
                aLog.append(" (");
                for (String service : _addedServices.keySet()) {
                    aLog.append(service + ", ");
                }
                aLog.append(") ");
            }
            aLog.append("]");
            return aLog.toString();
        }

    }

    public static class ServiceTypeListenerStatus extends ListenerStatus<ServiceTypeListener> {
        private static Logger                       logger = Logger.getLogger(ServiceTypeListenerStatus.class.getName());

        private final ConcurrentMap<String, String> _addedTypes;

        /**
         * @param listener
         *            listener being tracked.
         * @param synch
         *            true if that listener can be called asynchronously
         */
        public ServiceTypeListenerStatus(ServiceTypeListener listener, boolean synch) {
            super(listener, synch);
            _addedTypes = new ConcurrentHashMap<String, String>(32);
        }

        /**
         * A new service type was discovered.
         * 
         * @param event
         *            The service event providing the fully qualified type of the service.
         */
        void serviceTypeAdded(ServiceEvent event) {
            if (null == _addedTypes.putIfAbsent(event.getType(), event.getType())) {
                this.getListener().serviceTypeAdded(event);
            } else {
                logger.finest("Service Type Added called for a service type already added: " + event);
            }
        }

        /**
         * A new subtype for the service type was discovered.
         * 
         * <pre>
         * &lt;sub&gt;._sub.&lt;app&gt;.&lt;protocol&gt;.&lt;servicedomain&gt;.&lt;parentdomain&gt;.
         * </pre>
         * 
         * @param event
         *            The service event providing the fully qualified type of the service with subtype.
         */
        void subTypeForServiceTypeAdded(ServiceEvent event) {
            if (null == _addedTypes.putIfAbsent(event.getType(), event.getType())) {
                this.getListener().subTypeForServiceTypeAdded(event);
            } else {
                logger.finest("Service Sub Type Added called for a service sub type already added: " + event);
            }
        }

        /*
         * (non-Javadoc)
         * @see java.lang.Object#toString()
         */
        @Override
        public String toString() {
            StringBuilder aLog = new StringBuilder(2048);
            aLog.append("[Status for ");
            aLog.append(this.getListener().toString());
            if (_addedTypes.isEmpty()) {
                aLog.append(" no type event ");
            } else {
                aLog.append(" (");
                for (String type : _addedTypes.keySet()) {
                    aLog.append(type + ", ");
                }
                aLog.append(") ");
            }
            aLog.append("]");
            return aLog.toString();
        }

    }

    public final static boolean SYNCHONEOUS  = true;
    public final static boolean ASYNCHONEOUS = false;

    private final T             _listener;

    private final boolean       _synch;

    /**
     * @param listener
     *            listener being tracked.
     * @param synch
     *            true if that listener can be called asynchronously
     */
    public ListenerStatus(T listener, boolean synch) {
        super();
        _listener = listener;
        _synch = synch;
    }

    /**
     * @return the listener
     */
    public T getListener() {
        return _listener;
    }

    /**
     * Return <cod>true</code> if the listener must be called synchronously.
     * 
     * @return the synch
     */
    public boolean isSynchronous() {
        return _synch;
    }

    /*
     * (non-Javadoc)
     * @see java.lang.Object#hashCode()
     */
    @Override
    public int hashCode() {
        return this.getListener().hashCode();
    }

    /*
     * (non-Javadoc)
     * @see java.lang.Object#equals(java.lang.Object)
     */
    @Override
    public boolean equals(Object obj) {
        return (obj instanceof ListenerStatus) && this.getListener().equals(((ListenerStatus<?>) obj).getListener());
    }

    /*
     * (non-Javadoc)
     * @see java.lang.Object#toString()
     */
    @Override
    public String toString() {
        return "[Status for " + this.getListener().toString() + "]";
    }
}