Device remoteDevice;

try {
    // connect the device which IP address is "192.168.1.20"
    remoteDevice  = new TcpDevice("192.168.1.20");
} catch (DeviceCreationException dce) {
    // connection failed, handle exception
}

device.release();

device.requestScan();

device.addListener(new DemoEventHandler());

public class DemoEventHandler implements BasicEventHandler, DoorEventHandler
{
    @Override
    public void deviceDisconnected()
    {
        // BasicEventHandler
        System.out.println("Device disconnected.");
    }

    @Override
    public void deviceStatusChanged(DeviceStatus status)
    {
        // BasicEventHandler
        System.out.println("Device status: "+status);
    }

    @Override
    public void doorOpened()
    {
        // DoorEventHandler
        System.out.println("Door opened.");
    }

    @Override
    public void doorClosed()
    {
        // DoorEventHandler
        System.out.println("Door closed.");
    }

    @Override
    public void doorOpenDelay()
    {
        // DoorEventHandler
        System.out.println("Door open for too long.");
    }

    @Override
    public void scanCancelledByDoor()
    {
        // DoorEventHandler
        System.out.println("Scan cancelled by door.");
    }
}

• Create a new event listener implementing ScanEventHandler, and add it with addListener, or
• Implement ScanEventHandler with the existing class DemoEventHandler (see above)

// [...] other events from ScanEventHandler have been hidden

@Override
public void scanStarted()
{
    System.out.println("Scan started!");
}

@Override
public void scanCompleted()
{
    // the inventory (resulting from the scan) is ready
    System.out.println("Scan completed!");
}

@Override
public void tagAdded(String tagUid)
{
    // a tag has been detected during the scan
    System.out.println(String.format("Tag scanned: %s", tagUid));
}

device.addListener(new AbstractEventHandler()
{
    // from ScanEventHandler
    @Override
    public void scanCompleted()
    {
        // ask to light all the tags detected during the last scan
        device.startLightingTagsLed(_currentDevice.getLastInventory().getTagsAll());
    }

    // from LedEventHandler
    @Override
    public void lightingStarted(List missingTags)
    {
        System.out.println("Lighting started!");
    }
});

// Note: with remote devices, getLastInventory can return 'null' in case of communication errors
Inventory inventory = device.getLastInventory();
System.out.println(String.format("%d tags have been scanned.", inventory.getNumberTotal());
// prints: "X tags have been scanned." (with X the result of getNumberTotal)

@Override
public void scanCompleted()
{
    // Note: with remote devices, getLastInventory can return 'null' in case of errors
    Inventory lastInventory = device.getLastInventory();

    // any other value than UNDEFINED: automatic scan (BADGE or FINGERPRINT)
    if(lastInventory.getAccessType() != AccessType.UNDEFINED)
    {
        // splitted for more readability
        String display = String.format("New Inventory available. User: %s, Access: %s.",
        lastInventory.getUsername(),
        lastInventory.getAccessType().name());

        // prints "New Inventory available. User: John, Access: BADGE."
        System.out.println(display);
    }

    // Manual scan, no username (empty)
    else
    {
        System.out.println("Manual scan completed.");
    }
}

// remoteDevice is an instance of TcpDevice
// get a list of inventories, ordered by ascending creation date
List<Inventory> inventories = remoteDevice.getInventories(dateFrom, dateTo);

// get all the tags scanned in the last inventory
List<String> tagsList = device.getLastInventory().getTagsAll();

// send an order to light this list
if(device.startLightingTagsLed(tagsList))
{
    // at this stage, the device confirmed the order, but we assume that it started lighting
    // let the LED's blink during 4500 milliseconds
    Thread.sleep(4500);
}

else
{
    System.out.println("Could not start the lighting operation.");
}

if(!device.stopLightingTagsLed())
{
    System.out.println("Could not stop the lighting operation.");
}

public class DemoEventHandler implements LedEventHandler
{
    @Override
    public void lightingStarted(List<String> tagsNotLighted)
    {
        // LedEventHandler
        System.out.println("Lighting started.");

        if(!tagsNotLighted.isEmpty())
        {
            System.out.println("Tags not lighted:");

            for(String uid : tagsNotLighted)
            {
                System.out.println(String.format("- %s", uid));
            }
        }

        // from here, a separate timer (or thread) could
        // wait for an event or a given delay to stop the lighting process.
    }

    @Override
    public void lightingStopped(List<String> tagsNotLighted)
    {
        // LedEventHandler
        System.out.println("Lighting stopped.");
    }
}

String currentUid   = "3006789456";
String newUid       = "ITEM000001";

// if the operation is successful, tag 3006789456 will become tag ITEM000001
RewriteUidResult result = device.rewriteUid(currentUid, newUid);

switch(result)
{
    case WRITING_CONFIRMATION_FAILED:
        System.out.println("(Tag could not be confirmed with its new UID)");
        // yet, the writing operation completed, continue to the successful case:
        case WRITING_SUCCESS:
        System.out.println("Writing operation successful!");
        break;

    default:
        System.out.println("Operation failed.");
        break;
}

// get all "active" (authorized) users, including those with a permission "Undefined"
List<User> activeUsers = device.getUsersService().getUsers();
// get the name of each unregistered user
List<String> unregisteredUsers = device.getUsersService().getUnregisteredUsers();

// create the user "John" with the permission to open all doors
User userJohn = new User("John", GrantType.ALL);
// register him
device.getUsersService().addUser(userJohn);

// both methods return a boolean (true: success, false: failure)
device.getUsersService().updateBadgeNumber("John", "FOOBAR42");
device.getUsersService().updatePermission("John", GrantType.SLAVE);

// Remove the user's permission but keep him/her active
device.getUsersService().updatePermission("John", GrantType.UNDEFINED);
// Disable the user, who is put in the list of unregistered users
device.getUsersService().removeUser("Mike");

try {
    boolean result = device.getUsersService().enrollFinger("John", FingerIndex.RIGHT_MIDDLE);
    System.out.println(result ? "Enrollment completed!" : "Operation failed.");
} catch(TimeoutException te) {
    // Delay of five minutes exceeded
}

Map<FingerIndex, String> templates = new EnumMap<>(FingerIndex.class);
templates.put(FingerIndex.LEFT_RING, template1);
templates.put(FingerIndex.LEFT_INDEX, template2);

User userMark = new User("Mark", GrantType.ALL, "", templates);
device.getUsersService().addUser(userMark);

device.getUsersService().removeFingerprint("Sam", FingerIndex.LEFT_RING);

// remoteDevice is an instance of TcpDevice
// get a list of authentications, ordered by ascending creation date
List<Authentication> authentications = remoteDevice.getAuthentications(dateFrom, dateTo);

double currentMeasure = device.getCurrentTemperature();
System.out.println(currentMeasure + "°C");

 // [...] other events

@Override
public void temperatureMeasure(double value)
{
    System.out.println("New temperature: "+value+"°C.");
}

// remoteDevice is an instance of TcpDevice
// get a map of Date and Double (value), ordered by ascending creation date
Map<Date, Double> measures = remoteDevice.getTemperatureMeasures(dateFrom, dateTo);