2008-05-14T00:45:48Z

Jmaine:

[[category:developerDoc]]
Junit 4.x may be tricky at first to build test suites or regular tests, but they are pretty easy to write once one gains a hang of it.

Here is an example of a regular test class.
<pre><nowiki>
import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.BeforeClass;
import org.junit.Test;

public class Example {
@BeforeClass
public static void setUpBeforeClass() throws Exception {
/* things to do before running tests */
}

@AfterClass
public static void tearDownAfterClass() throws Exception {
/* things to do after running tests */
}

@Test
public void testExample1() {

}

@Test
public void testExample2() {

}

}
</nowiki></pre>

 
 
Here is an example of a test suite. This class can be subclassed to create sub-suites to keep from writing
boiler plate code over and over.
<pre><nowiki>
import java.util.ArrayList;

import org.junit.runner.Description;
import org.junit.runner.RunWith;
import org.junit.runner.Runner;
import org.junit.runner.notification.RunNotifier;

/*
* This is the runner class for the entire test suite.
* All we do here is to add the sub suites here.
*
* This class can be subclassed to create subsuites.
* Note the run with annotation is needed for each subsuite.
* And each subsuite must have a constructor with a signature of
* public [constructor] (Class<?> klass)
*/
@RunWith(SuiteExample.class)
public class SuiteExample extends Runner {
protected Description description;
protected ArrayList<Runner> runners;

public ReaderTests()
{
runners = new ArrayList<Runner>();
};

public ReaderTests (Class<?> klass)
{
this();

runners.add(Request.aClass(Example.class).sortWith(this).getRunner());

description = Description.createSuiteDescription("Rifidi Junit Test Suite");

addRunnersToDescription();
}

/* call this method in the constructor of the subclass
* to add the runners to the description
*/
protected void addRunnersToDescription()
{
for(Runner run : runners)
{
description.addChild(run.getDescription());
}
}

@Override
public Description getDescription() {

return description;
}

@Override
public void run(RunNotifier notifier) {

notifier.fireTestStarted(description);
for (Runner run : runners)
{
notifier.fireTestStarted(run.getDescription());
run.run(notifier);
notifier.fireTestFinished(run.getDescription());
}
notifier.fireTestFinished(description);

}

}
</nowiki></pre>

2008-04-17T20:00:47Z

Jmaine:

READERNAME Protocol.java

2008-04-17T19:54:06Z

Jmaine: /* removeProtocol */

[[category:developerDoc]][[category:emulatorDoc]]
This class removes protocols from incoming messages and adds protocols to outgoing messages. In addition it parses incoming messages to make sure that only one command at a time is placed on the incoming message buffer. See [[Command Flow]]. This class should implement Protocol. If nothing special needs to happen, the reader can use RawProtocol.

=addProtocol=

This method adds a protocol to outgoing messages. For example, if the outgoing message needs to be an HTTP message, the protocol should construct the necessary HTTP part of the outgoing message

<pre>public byte[] addProtocol(byte[] data);</pre>

==Arguments==
# data - The response from the reader that needs a protocol added to it.

==Return Value==
A message that is properly encoded with the correct protocol that is ready to be sent back to the client.

==Reference Implementation==
This is the implementation of the addProtocol() method in the alien reader. For it, nothing special needs to happen.
<pre>
public byte[] addProtocol(byte[] data) {
return data;
}
</pre>

=removeProtocol=

This method removes protocols on incoming messages. It also splits up commands if more than two commands are sent at the same time and read from the TCP socket all at once. These command are sent one at a time to [[READERNAME_CommandFormatter.java]]::decode(byte[] arg) to be parsed and sent to the command handler.

<pre>public List<byte[]> removeProtocol(byte[] data);</pre>

==Arguments==
# data - A list of bytes that has been read from the TCP socket

==Return Value==
A list of commands, where each item in the list is a single command

==Reference Implementation==
This is the implementation of the removeProtocol() method in the alien reader. It splits up messages using '\n' as a deliminator. It then puts each individual message in its own slot in an array and returns the array.
<pre>
public List<byte[]> removeProtocol(byte[] data)
throws ProtocolValidationException {
List<byte[]> retVal = new ArrayList<byte[]>();
String strData = new String(data);
String[] arrayData = strData.split("\n");
for( String i:arrayData ) {
retVal.add(i.getBytes());
}
return retVal;
}
</pre>

READERNAME Protocol.java

2008-04-17T19:53:49Z

Jmaine: /* removeProtocol */

[[category:developerDoc]][[category:emulatorDoc]]
This class removes protocols from incoming messages and adds protocols to outgoing messages. In addition it parses incoming messages to make sure that only one command at a time is placed on the incoming message buffer. See [[Command Flow]]. This class should implement Protocol. If nothing special needs to happen, the reader can use RawProtocol.

=addProtocol=

This method adds a protocol to outgoing messages. For example, if the outgoing message needs to be an HTTP message, the protocol should construct the necessary HTTP part of the outgoing message

<pre>public byte[] addProtocol(byte[] data);</pre>

==Arguments==
# data - The response from the reader that needs a protocol added to it.

==Return Value==
A message that is properly encoded with the correct protocol that is ready to be sent back to the client.

==Reference Implementation==
This is the implementation of the addProtocol() method in the alien reader. For it, nothing special needs to happen.
<pre>
public byte[] addProtocol(byte[] data) {
return data;
}
</pre>

=removeProtocol=

This method removes protocols on incoming messages. It also splits up commands if more than two commands are sent at the same time and read from the TCP socket all at once. These command are sent one at a time to [[/READERNAME_CommandFormatter.java]]::decode(byte[] arg) to be parsed and sent to the command handler.

<pre>public List<byte[]> removeProtocol(byte[] data);</pre>

==Arguments==
# data - A list of bytes that has been read from the TCP socket

==Return Value==
A list of commands, where each item in the list is a single command

==Reference Implementation==
This is the implementation of the removeProtocol() method in the alien reader. It splits up messages using '\n' as a deliminator. It then puts each individual message in its own slot in an array and returns the array.
<pre>
public List<byte[]> removeProtocol(byte[] data)
throws ProtocolValidationException {
List<byte[]> retVal = new ArrayList<byte[]>();
String strData = new String(data);
String[] arrayData = strData.split("\n");
for( String i:arrayData ) {
retVal.add(i.getBytes());
}
return retVal;
}
</pre>

READERNAME CommandFormatter.java

2008-04-17T19:50:48Z

Jmaine: /* Return Value */

[[category:developerDoc]][[category:emulatorDoc]]
This class should implement CommandHandler. This page goes through each of the four methods in CommandHandler and describes in detail what each one does and how it should be implemented. The first two methods are important, and the last two methods are not as important.

=decode=

This method needs to decode an incoming command into a command to be handled in the command formatter. It should put the command into a commandObject and put the commandObject in the first slot in an arraylist and return the arraylist. Normally the command object is a string that Rifidi uses to find the the appropriate command handler. The rest of the slots in the ArrayList may be used to pass arguments to the command handler, i.e. a coherent object that contains the the information already parsed and ready for consumption.

<pre>public ArrayList<Object> decode(byte[] arg);</pre>

==Arguments==
#arg - The incoming command as an array of bytes.

==Return Value==
An array of objects where the first object is a command in the correct format to be processed by the command handler

==Reference Implementation==
This is the decode method in the alien reader
<pre>
public ArrayList<Object> decode(byte[] arg) {
if (arg.length == 0) {
ArrayList<Object> argArray = new ArrayList<Object>();
argArray.add("");
console = false;
return argArray;
}
String newString = new String(arg);

logger.debug("Formatter arg: " + newString);

ArrayList<Object> retVal = this.parseCommand(newString);

return retVal;
}
</pre>

=encode=
After a command has been processed by the command handler, the response it returns must be formatted to be sent back out to the client.
<pre>public ArrayList<Object> encode(ArrayList<Object> arg);</pre>

==Arguments==
#arg - The return message(s) before they has been processed is in the array of objects

==Return Value==
An array of objects where each object is a formatted response message ready to be sent back to the client. It must be formatted in a way that [[READERNAME_Protocol.java]]::addProtocol() can understand.

==Reference Implementation==
This is the encode method for the symbol reader. Because some commands in the symbol reader need to have more than one response message (e.g. a data message and a final message), more than one raw message can be in the array list in arg. For each message, the CRC must be calculated and appended.
<pre>
public ArrayList<Object> encode(ArrayList<Object> arg) {

ArrayList<Object> retVal = new ArrayList<Object>();

for (Object o : arg) {
byte[] command = (byte[]) o;

/*
* Create outgoing array list that is 3 slots bigger than incoming
* one: one for start of frame and two for crc bytes
*/
byte[] outgoingCommand = new byte[command.length + 3];
for (int i = 0; i < command.length; i++) {
outgoingCommand[i + 1] = command[i];
}

/* Add Start of Frame Byte */
outgoingCommand[0] = 0x01;

// Calculate CRC
int crc = CRC16.calculateCRC(command, 0xBEEF,
CRC16.XR400_CRC_TABLE, true);
byte[] crcBytes = ByteAndHexConvertingUtility
.intToByteArray(crc, 2);

// put crc in outgoingCommand, LSB first
outgoingCommand[outgoingCommand.length - 2] = crcBytes[1];
outgoingCommand[outgoingCommand.length - 1] = crcBytes[0];

logger.debug(ByteAndHexConvertingUtility.toHexString(outgoingCommand));

retVal.add(outgoingCommand);

}

return retVal;
}
</pre>

=promptSuppress=
This method is mainly used by the alien reader to determine if the reader should supress the prompt when sending back a response. Other readers may need similar functionality.

<pre>public boolean promptSuppress();</pre>

==Arguments==

==Return Value==
true if the prompt should be surpressed

=getActualCommand=
This method is mainly used by the alien reader to return a string that a user actually typed in. Other readers may need similar functionality

<pre>public String getActualCommand(byte[] arg);</pre>

==Arguments==
#arg - The incoming command

==Return Value==
A string that is the command the user typed in

READERNAME CommandFormatter.java

2008-04-17T19:43:21Z

Jmaine: /* decode */

[[category:developerDoc]][[category:emulatorDoc]]
This class should implement CommandHandler. This page goes through each of the four methods in CommandHandler and describes in detail what each one does and how it should be implemented. The first two methods are important, and the last two methods are not as important.

=decode=

This method needs to decode an incoming command into a command to be handled in the command formatter. It should put the command into a commandObject and put the commandObject in the first slot in an arraylist and return the arraylist. Normally the command object is a string that Rifidi uses to find the the appropriate command handler. The rest of the slots in the ArrayList may be used to pass arguments to the command handler, i.e. a coherent object that contains the the information already parsed and ready for consumption.

<pre>public ArrayList<Object> decode(byte[] arg);</pre>

==Arguments==
#arg - The incoming command as an array of bytes.

==Return Value==
An array of objects where the first object is a command in the correct format to be processed by the command handler

==Reference Implementation==
This is the decode method in the alien reader
<pre>
public ArrayList<Object> decode(byte[] arg) {
if (arg.length == 0) {
ArrayList<Object> argArray = new ArrayList<Object>();
argArray.add("");
console = false;
return argArray;
}
String newString = new String(arg);

logger.debug("Formatter arg: " + newString);

ArrayList<Object> retVal = this.parseCommand(newString);

return retVal;
}
</pre>

=encode=
After a command has been processed by the command handler, the response it returns must be formatted to be sent back out to the client.
<pre>public ArrayList<Object> encode(ArrayList<Object> arg);</pre>

==Arguments==
#arg - The return message(s) before they has been processed is in the array of objects

==Return Value==
An array of objects where each object is a formatted response message ready to be sent back to the client.

==Reference Implementation==
This is the encode method for the symbol reader. Because some commands in the symbol reader need to have more than one response message (e.g. a data message and a final message), more than one raw message can be in the array list in arg. For each message, the CRC must be calculated and appended.
<pre>
public ArrayList<Object> encode(ArrayList<Object> arg) {

ArrayList<Object> retVal = new ArrayList<Object>();

for (Object o : arg) {
byte[] command = (byte[]) o;

/*
* Create outgoing array list that is 3 slots bigger than incoming
* one: one for start of frame and two for crc bytes
*/
byte[] outgoingCommand = new byte[command.length + 3];
for (int i = 0; i < command.length; i++) {
outgoingCommand[i + 1] = command[i];
}

/* Add Start of Frame Byte */
outgoingCommand[0] = 0x01;

// Calculate CRC
int crc = CRC16.calculateCRC(command, 0xBEEF,
CRC16.XR400_CRC_TABLE, true);
byte[] crcBytes = ByteAndHexConvertingUtility
.intToByteArray(crc, 2);

// put crc in outgoingCommand, LSB first
outgoingCommand[outgoingCommand.length - 2] = crcBytes[1];
outgoingCommand[outgoingCommand.length - 1] = crcBytes[0];

logger.debug(ByteAndHexConvertingUtility.toHexString(outgoingCommand));

retVal.add(outgoingCommand);

}

return retVal;
}
</pre>

=promptSuppress=
This method is mainly used by the alien reader to determine if the reader should supress the prompt when sending back a response. Other readers may need similar functionality.

<pre>public boolean promptSuppress();</pre>

==Arguments==

==Return Value==
true if the prompt should be surpressed

=getActualCommand=
This method is mainly used by the alien reader to return a string that a user actually typed in. Other readers may need similar functionality

<pre>public String getActualCommand(byte[] arg);</pre>

==Arguments==
#arg - The incoming command

==Return Value==
A string that is the command the user typed in

REDERNAME Module.java

2008-04-17T19:30:03Z

Jmaine: /* Other Notes */

[[category:developerDoc]][[category:emulatorDoc]]
The readerModule is the constructor for the reader. Every reader needs one of these classes. The class needs to extend AbstractPowerModule and implement ReaderModule.

=READERNAMEModule=
This is the main constructor for the reader There should actually be two constructors. One is an empty constructor that is needed for jaxb to automatically create the reader. It should look like this:

<pre>
public SymbolReaderModule(){
}
</pre>

The readermodule also needs a main constructor with this signature:
<pre>
public SymbolReaderModule(ControlSignal<Boolean> powerControlSignal,GeneralReaderPropertyHolder properties);
</pre>

==Arguments==
# powerControlSignal - The power control signal for the entire reader. It is used to turn the reader on and off as well as to suspend and resume the reader. See information on the power states in the module package for more explanation of this.
# properties - These are the properties that the reader creation wizzard constructed. The GeneralReaderPropertyHolder contains the information required by the [[emulator.xml]].

==Reference Implementation==
This is the constructor for the SymbolReaderModule.

<pre>
public SymbolReaderModule(ControlSignal<Boolean> powerControlSignal,
GeneralReaderPropertyHolder properties) {
</pre>
always start out with a call to the super class
<pre>
super(SymbolReaderModuleOffPowerState.getInstance(),powerControlSignal);
</pre>
write some basic information to the console to let the user know that the reader is starting. Note that we are getting some information from the generalRederProperyHolder
<pre>
consoleLogger = LogFactory.getLog("console."
+ properties.getReaderName());
consoleLogger.info(SymbolReaderModule.startupText
+ "Instantiated Symbol Reader with name: "
+ properties.getReaderName());
consoleLogger.info(SymbolReaderModule.startupText
+ properties.getReaderName() + " IP Address: "
+ properties.getProperty("byte_address"));
consoleLogger.info(SymbolReaderModule.startupText
+ properties.getReaderName() + " has "
+ properties.getNumAntennas() + " antennas");
</pre>
set the name of the reader equal to the name given in the generalReaderPropertyHolder
<pre>
this.name = properties.getReaderName();
</pre>
Initialize the digester and read in the command hander methods supplied in the [[reader.xml]] file
<pre>
digester = new CommandXMLDigester();
digester.parseToCommand(this.getClass().getClassLoader()
.getResourceAsStream(XMLLOCATION + "reader.xml"));
</pre>
Create a new tag memory, create antennas, create a new radio and supply the tagMemory and antennas to the radio
<pre>
SymbolTagMemory tagMemory = new SymbolTagMemory();

HashMap<Integer, Antenna> antennaList = new HashMap<Integer, Antenna>();
for (int i = 0; i < properties.getNumAntennas(); i++) {
logger.debug("creating an antenna: " + i);
antennaList.put(i, new Antenna(i));
}

/* Make a Radio for the reader */
GenericRadio genericRadio = new GenericRadio(antennaList, 25, tagMemory);
</pre>
The symbol reader has two different IP addresses being used. One is for byte commands, and the other is for HTTP commands. parse out the IPs and ports from the GeneralReaderPropertyHolder
<pre>
String byte_address = ((String) properties.getProperty("byte_address"))
.split(":")[0];
int byte_port = Integer.parseInt(((String) properties
.getProperty("byte_address")).split(":")[1]);

String http_address = ((String) properties.getProperty("http_address"))
.split(":")[0];
int http_port = Integer.parseInt(((String) properties
.getProperty("http_address")).split(":")[1]);
</pre>
create the shared resources and supply necessary information to it
<pre>
this.srsr = new SymbolReaderSharedResources(genericRadio, tagMemory,
new ControlSignal<Boolean>(false), name, null, digester,
new ControlSignal<Boolean>(false), new ControlSignal<Boolean>(
false), new ControlSignal<Boolean>(false),
new ControlSignal<Boolean>(false), antennaList.size());
</pre>
Create the communication objects. In this case, we need two communication objects (one for bytes, and one for http), however, most readers will probably only need one. Notice that this is where we supply the reader with the [[READERNAME_Protocol.java|Protocol]], [[READERNAME_StreamReaderFormatter.java|Stream Reader]], and [[READERNAME_LogFormatter.java|Log Formatter]]
<pre>
this.httpComm = new TCPServerCommunication(new RawProtocol(), this.srsr
.getInteractiveHttpPowerSignal(), this.srsr
.getInteractiveHttpConnectionSignal(), http_address, http_port,
this.name, GenericByteStreamReader.class, new GenericByteLogFormatter());

this.byteComm = new TCPServerCommunication(new RawProtocol(), this.srsr
.getInteractiveBytePowerSignal(), this.srsr
.getInteractiveByteConnectionSignal(), byte_address, byte_port,
this.name, GenericByteStreamReader.class, new GenericByteLogFormatter());
</pre>
Build the adapters for this reader. Again, because the Symbol reader has two ways of communicating, we need two adapters. See [[Command Flow]] for more information about the adapter. This is where we supply the reader with the [[READERNAME_CommandFormatter.java|CommandFormatter]] and the [[READERNAME_ExceptionHanlder.java|ExceptionHandler]]
<pre>
this.interactiveBitAdapter = new ReflectiveCommandAdapter(
"Interactive", new SymbolBitCommandFormatter(), new SymbolBitExceptionHandler(),
this.srsr, new RawCommandSearcher());

this.interactiveHttpAdapter = new ReflectiveCommandAdapter(
"Interactive", null, new SymbolBitExceptionHandler(), this.srsr, new RawCommandSearcher());
</pre>
Build the controllers.
<pre>
this.interactiveBitController = new InteractiveCommandController(
new LoginAuthenticatedCommandControllerOperatingState(
interactiveBitAdapter), this.srsr
.getInteractiveBytePowerSignal(), this.srsr
.getInteractiveByteConnectionSignal(), this.byteComm);

this.interactiveHttpController = new InteractiveCommandController(
new LoginAuthenticatedCommandControllerOperatingState(
interactiveHttpAdapter), this.srsr
.getInteractiveHttpPowerSignal(), this.srsr
.getInteractiveHttpConnectionSignal(), this.httpComm);
}
</pre>
=Other Notes=
Here is an example from the Thing Magic reader:
<pre>
this.RQLComm = new TCPServerCommunication(new ThingMagicProtocol(), this.tmsr
.getInteractiveRQLPowerSignal(), this.tmsr
.getInteractiveRQLConnectionSignal(), rql_address, rql_port,
this.name, GenericCharStreamReader.class, new GenericStringLogFormatter());
</pre>
Notice the difference of this from the Symbol example. We are using GenericCharStreamReader and GenericStringLogFormatter instead. These are used when a client can be a standard telnet connection (another example of this is the Alien reader). 

In addition, if you need to override the default command searcher, RawCommandSearcher, then replace this class with a different implementation and pass it to ReflectiveCommandAdapter instead of the default one.

Also, one can add a few more parameters to ones implementation of the shared resources if it that information (object or primitive type) if it is needed across different areas of the reader (including its accessors and mutators if needed).

=Other Methods=
The ReaderModule will also need to implement some other methods required by the interface that it implements, however, these methods should be nearly identical to similar methods in the other readers. Please see the other readers and follow examples there for more information.

REDERNAME Module.java

2008-04-17T19:25:20Z

Jmaine:

[[category:developerDoc]][[category:emulatorDoc]]
The readerModule is the constructor for the reader. Every reader needs one of these classes. The class needs to extend AbstractPowerModule and implement ReaderModule.

=READERNAMEModule=
This is the main constructor for the reader There should actually be two constructors. One is an empty constructor that is needed for jaxb to automatically create the reader. It should look like this:

<pre>
public SymbolReaderModule(){
}
</pre>

The readermodule also needs a main constructor with this signature:
<pre>
public SymbolReaderModule(ControlSignal<Boolean> powerControlSignal,GeneralReaderPropertyHolder properties);
</pre>

==Arguments==
# powerControlSignal - The power control signal for the entire reader. It is used to turn the reader on and off as well as to suspend and resume the reader. See information on the power states in the module package for more explanation of this.
# properties - These are the properties that the reader creation wizzard constructed. The GeneralReaderPropertyHolder contains the information required by the [[emulator.xml]].

==Reference Implementation==
This is the constructor for the SymbolReaderModule.

<pre>
public SymbolReaderModule(ControlSignal<Boolean> powerControlSignal,
GeneralReaderPropertyHolder properties) {
</pre>
always start out with a call to the super class
<pre>
super(SymbolReaderModuleOffPowerState.getInstance(),powerControlSignal);
</pre>
write some basic information to the console to let the user know that the reader is starting. Note that we are getting some information from the generalRederProperyHolder
<pre>
consoleLogger = LogFactory.getLog("console."
+ properties.getReaderName());
consoleLogger.info(SymbolReaderModule.startupText
+ "Instantiated Symbol Reader with name: "
+ properties.getReaderName());
consoleLogger.info(SymbolReaderModule.startupText
+ properties.getReaderName() + " IP Address: "
+ properties.getProperty("byte_address"));
consoleLogger.info(SymbolReaderModule.startupText
+ properties.getReaderName() + " has "
+ properties.getNumAntennas() + " antennas");
</pre>
set the name of the reader equal to the name given in the generalReaderPropertyHolder
<pre>
this.name = properties.getReaderName();
</pre>
Initialize the digester and read in the command hander methods supplied in the [[reader.xml]] file
<pre>
digester = new CommandXMLDigester();
digester.parseToCommand(this.getClass().getClassLoader()
.getResourceAsStream(XMLLOCATION + "reader.xml"));
</pre>
Create a new tag memory, create antennas, create a new radio and supply the tagMemory and antennas to the radio
<pre>
SymbolTagMemory tagMemory = new SymbolTagMemory();

HashMap<Integer, Antenna> antennaList = new HashMap<Integer, Antenna>();
for (int i = 0; i < properties.getNumAntennas(); i++) {
logger.debug("creating an antenna: " + i);
antennaList.put(i, new Antenna(i));
}

/* Make a Radio for the reader */
GenericRadio genericRadio = new GenericRadio(antennaList, 25, tagMemory);
</pre>
The symbol reader has two different IP addresses being used. One is for byte commands, and the other is for HTTP commands. parse out the IPs and ports from the GeneralReaderPropertyHolder
<pre>
String byte_address = ((String) properties.getProperty("byte_address"))
.split(":")[0];
int byte_port = Integer.parseInt(((String) properties
.getProperty("byte_address")).split(":")[1]);

String http_address = ((String) properties.getProperty("http_address"))
.split(":")[0];
int http_port = Integer.parseInt(((String) properties
.getProperty("http_address")).split(":")[1]);
</pre>
create the shared resources and supply necessary information to it
<pre>
this.srsr = new SymbolReaderSharedResources(genericRadio, tagMemory,
new ControlSignal<Boolean>(false), name, null, digester,
new ControlSignal<Boolean>(false), new ControlSignal<Boolean>(
false), new ControlSignal<Boolean>(false),
new ControlSignal<Boolean>(false), antennaList.size());
</pre>
Create the communication objects. In this case, we need two communication objects (one for bytes, and one for http), however, most readers will probably only need one. Notice that this is where we supply the reader with the [[READERNAME_Protocol.java|Protocol]], [[READERNAME_StreamReaderFormatter.java|Stream Reader]], and [[READERNAME_LogFormatter.java|Log Formatter]]
<pre>
this.httpComm = new TCPServerCommunication(new RawProtocol(), this.srsr
.getInteractiveHttpPowerSignal(), this.srsr
.getInteractiveHttpConnectionSignal(), http_address, http_port,
this.name, GenericByteStreamReader.class, new GenericByteLogFormatter());

this.byteComm = new TCPServerCommunication(new RawProtocol(), this.srsr
.getInteractiveBytePowerSignal(), this.srsr
.getInteractiveByteConnectionSignal(), byte_address, byte_port,
this.name, GenericByteStreamReader.class, new GenericByteLogFormatter());
</pre>
Build the adapters for this reader. Again, because the Symbol reader has two ways of communicating, we need two adapters. See [[Command Flow]] for more information about the adapter. This is where we supply the reader with the [[READERNAME_CommandFormatter.java|CommandFormatter]] and the [[READERNAME_ExceptionHanlder.java|ExceptionHandler]]
<pre>
this.interactiveBitAdapter = new ReflectiveCommandAdapter(
"Interactive", new SymbolBitCommandFormatter(), new SymbolBitExceptionHandler(),
this.srsr, new RawCommandSearcher());

this.interactiveHttpAdapter = new ReflectiveCommandAdapter(
"Interactive", null, new SymbolBitExceptionHandler(), this.srsr, new RawCommandSearcher());
</pre>
Build the controllers.
<pre>
this.interactiveBitController = new InteractiveCommandController(
new LoginAuthenticatedCommandControllerOperatingState(
interactiveBitAdapter), this.srsr
.getInteractiveBytePowerSignal(), this.srsr
.getInteractiveByteConnectionSignal(), this.byteComm);

this.interactiveHttpController = new InteractiveCommandController(
new LoginAuthenticatedCommandControllerOperatingState(
interactiveHttpAdapter), this.srsr
.getInteractiveHttpPowerSignal(), this.srsr
.getInteractiveHttpConnectionSignal(), this.httpComm);
}
</pre>
=Other Notes=
Here is an example from the Thing Magic reader:
<pre>
this.RQLComm = new TCPServerCommunication(new ThingMagicProtocol(), this.tmsr
.getInteractiveRQLPowerSignal(), this.tmsr
.getInteractiveRQLConnectionSignal(), rql_address, rql_port,
this.name, GenericCharStreamReader.class, new GenericStringLogFormatter());
</pre>
Notice the difference of this from the Symbol example. We are using GenericCharStreamReader and GenericStringLogFormatter instead. These are used when a client can be a standard telnet connection (another example of this is the Alien reader). 

In addition, if you need to override the default command searcher, RawCommandSearcher, then replace this class with a different implementation and pass it to ReflectiveCommandAdapter instead of the default one.

=Other Methods=
The ReaderModule will also need to implement some other methods required by the interface that it implements, however, these methods should be nearly identical to similar methods in the other readers. Please see the other readers and follow examples there for more information.

ThingMagic/Emulator Architecture

2008-04-17T17:56:49Z

Jmaine:

Here is the UML diagram for the ThingMagic specific parts of the emulator in Rifidi.
[[Image:Thingmagic.png|800px]]

Here is the flow diagram for the emulator.
[[Image:Thingmagic_flow_diagram.png]]

File:Thingmagic flow diagram.png

2008-04-17T17:55:50Z

Here is the UML diagram for the ThingMagic specific parts of the emulator in Rifidi.

ThingMagic

2008-04-12T17:55:51Z

Jmaine:

ThingMagic

2008-03-20T02:10:49Z

Jmaine: /* RQL Schema */

ThingMagic

2008-03-19T18:36:55Z

Jmaine:

Reader Activator.java

2008-02-23T03:18:58Z

Jmaine:

[[category:developerDoc]][[category:emulatorDoc]]
You should only modify Activator.java that was automatically created to create and register the reader--like this (Example taken from ThingMagic Reader):
<pre><nowiki>
public class Activator implements BundleActivator {

/*
* (non-Javadoc)
* @see org.eclipse.ui.plugin.AbstractUIPlugin#start(org.osgi.framework.BundleContext)
*/
public void start(BundleContext context) throws Exception {
System.out.println("Registered org.rifidi.emulator.reader.thingmagic");
context.registerService(new String[]{ReaderModule.class.getName()}, new ThingMagicReaderModule(), new Hashtable());
}

/*
* (non-Javadoc)
* @see org.eclipse.ui.plugin.AbstractUIPlugin#stop(org.osgi.framework.BundleContext)
*/
public void stop(BundleContext context) throws Exception {
System.out.println("Shutting down org.rifidi.emulator.reader.thingmagic");
}

}
</nowiki></pre>
Notice those those three total lines of code in the methods '''start''' and '''stop'''. Those are the only lines one has to add then chance '''ThingMagic''' or '''thingmagic''' to match the name of the reader one is building.

Reader Activator.java

2008-02-23T03:10:05Z

Jmaine: New page: You should only modify Activator.java that was automatically created to create and register the reader--like this (Example taken from ThingMagic Reader): <pre><nowiki> public class Activat...

You should only modify Activator.java that was automatically created to create and register the reader--like this (Example taken from ThingMagic Reader):
<pre><nowiki>
public class Activator implements BundleActivator {

/*
* (non-Javadoc)
* @see org.eclipse.ui.plugin.AbstractUIPlugin#start(org.osgi.framework.BundleContext)
*/
public void start(BundleContext context) throws Exception {
System.out.println("Registered org.rifidi.emulator.reader.thingmagic");
context.registerService(new String[]{ReaderModule.class.getName()}, new ThingMagicReaderModule(), new Hashtable());
}

/*
* (non-Javadoc)
* @see org.eclipse.ui.plugin.AbstractUIPlugin#stop(org.osgi.framework.BundleContext)
*/
public void stop(BundleContext context) throws Exception {
System.out.println("Shutting down org.rifidi.emulator.reader.thingmagic");
}

}
</nowiki></pre>
Notice those those three total lines of code in the methods '''start''' and '''stop'''. Those are the only lines one has to add then chance '''ThingMagic''' or '''thingmagic''' to match the name of the reader one is building.

Package Structure for a reader project

2008-02-23T03:03:12Z

Jmaine: /* org.rifidi.emulator.reader.READERNAME */

[[category:developerDoc]][[category:emulatorDoc]]

Please refer to [[Create a new reader project | this document]] to figure out how to create a new reader project in eclipse

This page enumerates the very basic packages that a reader will need to have and the important files in each one. Complex readers will have more packages than these, but this is a bare minimum. These packages correspond with what you will need to program in [[Reader_Development_Stages#Stage_2_Reader_Core_Implementation| stage 2 of reader creation]].
==org.rifidi.emulator.reader.READERNAME==
This package just contains the osgi activator. It should be created for you automatically when you create the project. You have to modify it only to make sure it sets up the reader. [[Reader_Activator.java|Activator.java]]

==org.rifidi.emualtor.reader.READERNAME.command.exception==
This package contains a file that handles exceptions that occur in the parsing and execution of reader commands.
*[[READERNAME_ExceptionHanlder.java]]
==org.rifidi.emualtor.reader.READERNAME.commandhandler==
This package contains one or more files that handle incoming reader messages. Normally commands can be divided into general categories. For example, with the LLRP reader, there are a set of commands that deal with ROSPec messages (such as ADD_ROSPEC, ENABLE_ROSPEC, etc.) and a separate set of commands that deal with AccessSpec messages (such as ADD_ACCESSSPEC, ENABLE_ACCESSSPEC). So for the LLRP reader, there is one file called 'LLRPReaderOperationControl.java' that contains the handler methods for ROSpec commands and a file called 'LLRPAccessControl.java' that contains the handler methods for AccessSpec commands.
*[[READERNAME_CATEGORY_Handler.java]]
==org.rifidi.emualtor.reader.READERNAME.formatter==
Any kind of formatters used should go into this package. You will definitely need a formatter that handles the parsing of incoming and outgoing commands called
*[[READERNAME_CommandFormatter.java]]
But you may also need formatters such as
*[[READERNAME_LogFormatter.java]] (not required)
that handles how incoming and outgoing messages should look in the log file.
Another useful formatter that may be necessary is
*[[READERNAME_StreamReaderFormatter.java]] (not required)
that controls how bytes are read off of and written to the TCPSocket.

==org.rifidi.emulator.reader.READERNAME.protocol==
The protocol package contains one file whose purpose is twofold. The protocol needs to:
#strip any extra protocol-- such as HTTP that the reader uses to communicate-- off of incoming messages and apply these protocols back to outgoing messages.
#Sometimes two or more commands can be read off of the TCP socket at the same time if the messages are sent quickly. Therefore the protocol needs to make sure that each command is placed on the incoming buffer individually.
*[[READERNAME_Protocol.java]]

==org.rifidi.emualtor.reader.READERNAME.module==
The module is the heart of the reader. It contains all the essential classes to get the reader up and running.
*[[reader.xml]] is a file that has the mappings between command names and handler methods
*[[emulator.xml]] is a file that contains with some basic configuration information
*[[REDERNAME_Module.java]] has the constructor for the reader
*[[READERNAME_ReaderSharedResources.java]] - The shared resources for this reader. It allows various pieces of the reader to be accessed in different parts.
*[[READERNAME_ReaderModuleOnPowerState.java]] - contains the transition functions for how to go from on->off and on->suspend
*[[READERNAME_ReaderModuleOffPowerState.java]] - contains the transition functions for how to go from off->on
*[[READERNAME_ReaderModuleSuspendPowerState.java]] - contains the transition functions for how to go from suspended->on and suspended->off

==org.rifidi.emualtor.reader.READERNAME.tagbuffer==
Because every real reader has a slightly different way that they remember tags, each virtual reader will need a class to handle tag reads.
* [[READERNAME_TagMemory.java]] is a class that keeps up with tag reads for the reader.

ThingMagic

2008-02-14T02:12:34Z

Jmaine: /* Getting Tags */

ThingMagic

2008-02-14T01:53:56Z

Jmaine: /* Getting Tags */

ThingMagic

2008-02-14T01:37:06Z

Jmaine: /* Client Tools */