/* * Copyright 2004 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. * */package com.mycompany.adapter.sample;import java.util.logging.*;import java.util.List;import java.util.ArrayList;import java.util.LinkedList;import java.util.Properties;import java.util.Collection;import java.util.Iterator;import java.io.EOFException;import java.io.IOException;import java.io.InputStreamReader;import java.io.BufferedReader;import java.net.URL;import java.net.HttpURLConnection;import java.net.*;import java.text.MessageFormat;import com.sun.autoid.adapter.DeviceAdapter;import com.sun.autoid.adapter.AbstractReaderAdapter;import com.sun.autoid.adapter.AbstractSocketIO;import com.sun.autoid.adapter.AbstractSocketReaderIO;import com.sun.autoid.adapter.AbstractReaderIO;import com.sun.autoid.adapter.TimeoutException;import com.sun.autoid.adapter.ConnectionResetException;import com.sun.autoid.adapter.NotSupportedException;import com.sun.autoid.adapter.OutOfRangeException;import com.sun.autoid.adapter.command.GetTagListCommand;import com.sun.autoid.adapter.Indicator;import com.sun.autoid.identity.*;import com.sun.autoid.event.IdentifierListEvent;import com.sun.autoid.event.EventConstants;import com.sun.autoid.event.EventUtil;import com.sun.autoid.pmlcore.pmlparser.*;import com.sun.autoid.pmlcore.pml.*;public class SampleReaderIO extends AbstractSocketReaderIO {        private SampleAdapter adapter;    private PmlParser pmlParser;        private boolean autoMode = false;        /**      * Creates a new instance of SampleReaderIO     * @param adapter       the SampleAdapter performing the IO     * @param hostname      the String specifying the name of the reader to contact     * @param port          the port number the reader listens on     * @param version       passed through to the ReaderRequest and ReaderResponse to identify protocol version     * @param properties    the Properties of the Reader Adapter     * @throws Exception     */    public SampleReaderIO(SampleAdapter adapter, String hostname, int port, int version, Properties properties) throws Exception {        super(adapter, hostname, port, version, properties);        this.adapter = adapter;	pmlParser = new PmlParser();    }        /**     * Performs the actual exchange of bytes with the reader     * @param oCmd           the command Object that needs to be executed     * @param getResponse   the boolean value indicating whether to wait for the response     * @throws TimeoutException if the reader did not reply within the timeout specified during the creation of the ReaderIO     * @throws ConnectionResetException if the connection to the reader has been lost     * @throws IOException for any other error condition     */    public Object tellReader(Object oCmd, boolean getResponse) throws TimeoutException, IOException, ConnectionResetException {        String data;        StringBuffer response = null;        String cmd = (String)oCmd;                logger.log(Level.FINEST, "Tell reader: {0}", cmd);        try {            send(cmd);              // Send command to reader        } catch (IOException ioe) {            String message = MessageFormat.format("Exception sending command to {0} Reader",                new Object[] { adapter.getDeviceID() });            logger.log(Level.WARNING, message, ioe);            throw ioe;        }        if (!getResponse)            return null;                response = new StringBuffer();        while (true) {			// Loop until success or error.  Ignore data            data = getLine();            if(data == null)                throw new EOFException("Unexpected: End of file from reader socket");            if (data.length() == 0)                return response.toString();			// success            response.append(data);            if(logger.isLoggable(Level.FINEST)) {                logger.log(Level.FINEST, "Command response from {0} Reader: {1}",                    new Object[] {adapter.getDeviceID(), data});            }            if (data.length() >= 5 && data.startsWith("Error")) {                String message = MessageFormat.format("Command error from {0} Reader: {1}",                    new Object[] {adapter.getDeviceID(), data});                logger.log(Level.WARNING, message);                throw new IOException(message);            }        }    }        /**     * Performs the reader specific initialization sequence     * @param properties the reader adapter Properties     * @throws TimeoutException if communication with the reader could not be established within the given timeout     * @throws IOException if communication with the reader failed to I/O problems     * @throws Exception for any other problem     */        public void initialize(Properties properties) throws IOException, TimeoutException, Exception {        tellReader("Reset", false);    }        /**     * Returns true if AutoMode is supported by this reader     */    public boolean isAutoModeSupported() {        return true;    }        /**     * Sets the reader into Automatic mode, where the reader constantly generates     * taglist results and communicates them back to the adapter.     * @param frequency                 specifies how often (in msecs) the reader shuld communicate back to the adapter     * @throws NotSupportedException    if the reader can not be set into Automatic mode     * @throws TimeoutException         if the reader did not reply within the timeout specified during the creation of     *                                  the ReaderIO     * @throws ConnectionResetException if the connection to the reader has been lost     * @throws IOException              for any other error condition     */    public void setAutoModeOn(long frequency) throws IOException, ConnectionResetException, TimeoutException, NotSupportedException {                logger.log(Level.FINEST, "setAutoModeOn(" + frequency + ")");        tellReader("Set Auto Mode " +frequency, true);        autoMode = true;    }            /**     * Turns off Automatic mode     * taglist results and communicates them back to the adapter.     * @throws TimeoutException         if the reader did not reply within the timeout specified during the creation of     *                                  the ReaderIO     * @throws ConnectionResetException if the connection to the reader has been lost     * @throws IOException              for any other error condition     */    public void setAutoModeOff() throws IOException, ConnectionResetException, TimeoutException {                logger.log(Level.FINEST, "setAutoModeOff()");        if (autoMode)            tellReader("Reset", true);        autoMode = false;    }        /**     * Provides a Collection of EMSListEvents     * @param scanLength the number of milliseconds reader should scan for tags     * @return the Collection of EMSListEvent elements     * @throws TimeoutException if the reader did not reply within the timeout specified during the creation of the ReaderIO     * @throws ConnectionResetException if the connection to the reader has been lost     * @throws IOException for any other error condition     */    public Collection getTagList(long scanLength) throws IOException, ConnectionResetException, TimeoutException {        logger.log(Level.FINE, "getTagList() invoked {0}", adapter.getDeviceID());        // issue the request        tellReader("Get Tag List", false);          // get response        return listenForTags();    }        /**     * Listens for the tag list     * @return the Collection of EMSListEvent elements     * @throws TimeoutException         if the reader did not reply within the timeout specified during the creation of     *                                  the ReaderIO     * @throws ConnectionResetException if the connection to the reader has been lost     * @throws IOException              for any other error condition     */     public Collection listenForTags() throws IOException, ConnectionResetException, TimeoutException {        StringBuffer response = new StringBuffer();        String data = null;        while (true) {			// Loop until success or error.  Ignore data            data = getLine();            if(data == null)                throw new EOFException("Unexpected: End of file from reader socket");            if (data.length() == 0)                continue;			            response.append(data);            if(logger.isLoggable(Level.FINEST)) {                logger.log(Level.FINEST, "Command response from {0} Reader: {1}",                    new Object[] {adapter.getDeviceID(), data});            }            if(data.equals("</pmlcore:Sensor>"))                break;            if (data.length() >= 5 && data.startsWith("Error")) {                String message = MessageFormat.format("Command error from {0} Reader: {1}",                    new Object[] {adapter.getDeviceID(), data});                 logger.log(Level.WARNING, message);                throw new IOException(message);            }        }         String pml = response.toString();        logger.finest(pml);        LinkedList resultList = new LinkedList();	try {            Sensor sensor = pmlParser.unmarshalPML(pml);            IdentifierListEvent event = (IdentifierListEvent)EventUtil.toEvent(pml, sensor);            numTagsRead += event.getTagList().size();            numReads++;            resultList.add(event);	}catch(Exception ex) {            String message = MessageFormat.format("Error processing getTagList(): {0}", new Object[] { adapter.getDeviceID() });            logger.log(Level.SEVERE,message, ex);	}        return resultList;    }          /**     * Programs the single tag in the reader field of action     * @param id the Identifier to assign to the tag     * @param param the Object parameter to be used and interpreted by the reader     * @return the EPC written to the tag     * @throws IOException if an error occurred     * @throws ConnectionResetException if the connection to the reader has been lost