TestEvents.java

package example;

import java.math.BigInteger;
import java.util.logging.Level;
import java.util.logging.Logger;
import me.legrange.panstamp.Endpoint;
import me.legrange.panstamp.EndpointListener;
import me.legrange.panstamp.ModemException;
import me.legrange.panstamp.Network;
import me.legrange.panstamp.NetworkException;
import me.legrange.panstamp.NetworkListener;
import me.legrange.panstamp.PanStamp;
import me.legrange.panstamp.PanStampListener;
import me.legrange.panstamp.Parameter;
import me.legrange.panstamp.Register;
import me.legrange.panstamp.RegisterListener;

/**
 * This example shows how to work with the classes from Network, PanStamp, Register and Endpoint
 * so that events for all instances in the structure can be received. 
 * 
 * It is important to understand that when you add a listener (event handler) to an instance of one of these
 * classes, it is very likely that you may already have "missed" some events.
 * 
 * This examples demonstrates how to iterate through existing data and how to add listeners to receive future data. 
 * 
 * @author Gideon le Grange https://github.com/GideonLeGrange
 */
public class TestEvents {

    private static final String PORT = "/dev/tty.usbserial-A800HNMV";
    private static final int BAUD = 38400;
    private Network nw;
    private int seq = 0;

    public static void main(String... args) throws Exception {

        TestEvents te = new TestEvents();
        te.connect();
        te.setupListeners();
        while (true) {
            Thread.sleep(1000);
        }
    }

    /** Connect to serial port and start the network */
    private void connect() throws NetworkException {
        nw = Network.openSerial(PORT, BAUD);
    }

    /** Set up the listeners for the objects currently in the tree.
     * Note that we build and event handler that will call addPanstamp() when we are notified of a new panStamp, 
     * AND we call addPanstamp on devices already known when our code executes */
    private void setupListeners() throws NetworkException {
        nw.addListener(new NetworkListener() {

            @Override
            public void deviceDetected(Network gw, PanStamp dev) {
                addPanStamp(dev);
                say("N: Device with address %d added to network", dev.getAddress());
            }

            @Override
            public void deviceRemoved(Network gw, PanStamp dev) {
                say("N: Device with address %d removed to network", dev.getAddress());
            }

            @Override
            public void networkOpened(Network nw) {
                say("N: Opened");
            }

            @Override
            public void networkClosed(Network nw) {
                say("N: Closed");
            }
        });
        for (PanStamp ps : nw.getDevices()) {
            addPanStamp(ps);
        }
    }

    /** Do whatever we do if we have a new panStamp. */
    private void addPanStamp(PanStamp ps) {
        ps.addListener(new PanStampListener() {

            @Override
            public void productCodeChange(PanStamp dev, int manufacturerId, int productId) {
                say("P: Product code for %d changed to %d/%d\n", dev.getAddress(),
                        manufacturerId, productId);
            }

            @Override
            public void syncStateChange(PanStamp dev, int syncState) {
                say("P: Sync state for %d changed to %d\n", dev.getAddress(), syncState);
            }

            @Override
            public void registerDetected(PanStamp dev, Register reg) {
                addRegister(reg);
                say("P: Register %d detected for device %d", reg.getId(), dev.getAddress());
            }

            @Override
            public void syncRequired(PanStamp dev) {
                say("P: Sync required for device %d", dev.getAddress());
            }
        });
        for (Register reg : ps.getRegisters()) {
            addRegister(reg);
        }
    }

    /** do whatever we do if we have a new register */
    private void addRegister(Register reg) {
        reg.addListener(new RegisterListener() {

            @Override
            public void valueReceived(Register reg, byte[] value) {
                say("R: Value for %d updated to '%s'", reg.getId(), formatBytes(value));
            }

            @Override
            public void valueSet(Register reg, byte[] value) {
                say("R: Value for %d set to '%s'", reg.getId(), formatBytes(value));
            }

            @Override
            public void endpointAdded(Register reg, Endpoint ep) {
                addEndpoint(ep);
                say("R: Endpoint '%s' added to %d", ep.getName(), reg.getId());
            }

            @Override
            public void parameterAdded(Register reg, Parameter par) {
                say("R: Parameter '%s' added to %d", par.getName(), reg.getId());
            }
        });
        for (Endpoint ep : reg.getEndpoints()) {
            addEndpoint(ep);
        }
    }

    /** do what we do if we encounter a new endpoint */
    private void addEndpoint(Endpoint ep) {
        ep.addListener(new EndpointListener() {

            @Override
            public void valueReceived(Endpoint ep, Object value) {
                say("E: Value '%s' received for '%s'", ep.getName(), value);
            }
        });
    }

    private void disconnect() throws ModemException {
        nw.close();
    }

    private synchronized void say(String fmt, Object... args) {
        System.out.printf("[%04d] ", seq);
        System.out.printf(fmt, args);
        if (!fmt.endsWith("\n")) {
            System.out.println();
        }
        seq++;
    }

    private String formatBytes(byte val[]) {
        return new BigInteger(val).toString(16);
    }

}