SerialComManager (serial communication manager 1.0.4 API)

java.lang.Object
- com.embeddedunveiled.serial.SerialComManager

public final class SerialComManager
extends Object

Root of this library.

The WIKI page for this project is here : http://www.embeddedunveiled.com/

1: System information getOSType getCPUArchitecture	2: Serial ports and device discovery listAvailableComPorts listUSBdevicesWithInfo findComPortFromUSBAttributes isUSBDevConnected
3 : Miscellaneous openComPort closeComPort createBlockingIOContext unblockBlockingIOOperation destroyBlockingIOContext fineTuneReadBehaviour clearPortIOBuffers getInterruptCount findDriverServingComPort findIRQnumberForComPort getByteCountInPortIOBuffer getPortName	4 : Data exchange writeBytes (non-blocking) writeSingleByte (non-blocking) writeString (non-blocking) writeSingleInt (non-blocking) writeIntArray (non-blocking) writeBytesDirect (non-blocking) writeBytesBlocking (blocking) readBytes (blocking, non-blocking) readSingleByte (non-blocking) readString (non-blocking) readBytesDirect (non-blocking) readBytesBlocking (blocking) createInputByteStream (blocking, non-blocking) createOutputByteStream (blocking, non-blocking)
5 : Serial port configuration and control configureComPortData configureComPortControl getCurrentConfiguration getLinesStatus setRTS setDTR sendBreak	6 : Data, control and hot plug events registerDataListener unregisterDataListener registerLineEventListener unregisterLineEventListener registerUSBHotPlugEventListener unregisterUSBHotPlugEventListener
7 : File transfer protocol sendFile receiveFile	8 : IOCTL operations getIOCTLExecutor
9 : Vendor library interfaces getVendorLibInstance	10 : Serial over USB getSerialComUSBInstance
11 : Human interface device (HID) getSerialComHIDInstance	12 : Serial data to application as keystroke getSerialComKeyStrokeAppInstance

[x] Native layer if fails to throw exception when an error occurs would log error message to STDERR file. It is assumed that Java application running on production systems will deploy a Java logger which will redirect STDERR messages to a log file. This way if an error occurs and native layer could not throw exception for example in out of memory case it will still be logged for later analysis.

Version:: 1.0.4
Author:: Rishi Gupta

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`SerialComManager.BAUDRATE` Pre-defined enum constants for baud rate values.
`static class`	`SerialComManager.DATABITS` Pre-defined enum constants for number of data bits in a serial frame.
`static class`	`SerialComManager.ENDIAN` Pre-defined enum constants for defining endianness of data to be sent over serial port.
`static class`	`SerialComManager.FLOWCONTROL` Pre-defined enum constants for controlling data flow between DTE and DCE.
`static class`	`SerialComManager.FTPPROTO` Pre-defined enum constants for defining file transfer protocol to use.
`static class`	`SerialComManager.FTPVAR` Pre-defined enum constants for defining variant of file transfer protocol to use.
`static class`	`SerialComManager.NUMOFBYTES` Pre-defined enum constants for defining number of bytes given data can be represented in.
`static class`	`SerialComManager.PARITY` Pre-defined enum constants for enabling type of parity in a serial frame.
`static class`	`SerialComManager.SMODE` Pre-defined enum constants for defining behavior of byte stream.
`static class`	`SerialComManager.STOPBITS` Pre-defined enum constants for number of stop bits in a serial frame.

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`ABI_ARMEL` The value indicating soft float ABI.
`static int`	`ABI_ARMHF` The value indicating hard float ABI.
`static int`	`ARCH_AMD64` The common value indicating that the library is running on a 64 bit Intel x86_64 (x86-64/x64/Intel 64) and AMD amd64 based architecture.
`static int`	`ARCH_ARMV5` The value indicating that the library is running on a ARMv5 based architecture CPU.
`static int`	`ARCH_ARMV6` The value indicating that the library is running on a ARMv6 soft float based JVM.
`static int`	`ARCH_ARMV7` The value indicating that the library is running on a ARMv7 soft float based JVM.
`static int`	`ARCH_IA64` The value indicating that the library is running on a 64 bit Intel/HP Itanium based architecture.
`static int`	`ARCH_IA64_32` The value indicating that the library is running on an IA64 32 bit based architecture.
`static int`	`ARCH_PA_RISC32` The value indicating that the library is running on a 32 bit PA-RISC based architecture.
`static int`	`ARCH_PA_RISC64` The value indicating that the library is running on a 64 bit PA-RISC based architecture.
`static int`	`ARCH_PPC32` The value indicating that the library is running on a 32 bit PowerPC based architecture from Apple–IBM–Motorola.
`static int`	`ARCH_PPC64` The value indicating that the library is running on a 64 bit PowerPC based architecture from Apple–IBM–Motorola.
`static int`	`ARCH_PPC64LE` The value indicating that the library is running on a 64 bit PowerPC based architecture in little endian mode from Apple–IBM–Motorola.
`static int`	`ARCH_S390` The value indicating that the library is running on a 32 bit IBM S/390 system.
`static int`	`ARCH_S390X` The value indicating that the library is running on a 64 bit IBM S/390 system.
`static int`	`ARCH_SPARC32` The value indicating that the library is running on a 32 bit Sparc based architecture from Sun Microsystems.
`static int`	`ARCH_SPARC64` The value indicating that the library is running on a 64 bit Sparc based architecture from Sun Microsystems.
`static int`	`ARCH_UNKNOWN` The value indicating that platform architecture is unknown to SCM library.
`static int`	`ARCH_X86` The common value indicating that the library is running on a 32 bit Intel i386/i486/i586/i686/i786/i886/i986/IA-32 based architecture.
`static int`	`CTS` Clear to send mask bit constant for UART control line.
`static int`	`DCD` Data carrier detect mask bit constant for UART control line.
`static int`	`DEFAULT_READBYTECOUNT` Default number of bytes (1024) to read from serial port.
`static int`	`DSR` Data set ready mask bit constant for UART control line.
`static int`	`DTR` Data terminal ready mask bit constant for UART control line.
`static String`	`EXP_UNBLOCKIO` The exception message indicating that a blocked read method has been unblocked and made to return to caller explicitly (irrespective there was data to read or not).
`static String`	`JAVA_LIB_VERSION` Production release version of the serial communication manager library.
`static int`	`LOOP` Loop indicator mask bit constant for UART control line.
`static int`	`OS_ANDROID` The value indicating the Android operating system.
`static int`	`OS_FREEBSD` The value indicating the FreeBSD operating system..
`static int`	`OS_HP_UX` The value indicating the HP-UX operating system.
`static int`	`OS_IBM_AIX` The value indicating the IBM AIX operating system.
`static int`	`OS_LINUX` The value indicating the Linux operating system.
`static int`	`OS_MAC_OS_X` The value indicating the Mac OS X operating system.
`static int`	`OS_NETBSD` The value indicating the NetBSD operating system.
`static int`	`OS_OPENBSD` The value indicating the OpenBSD operating system.
`static int`	`OS_SOLARIS` The value indicating the Solaris operating system.
`static int`	`OS_UNKNOWN` The value indicating that operating system is unknown to SCM library.
`static int`	`OS_WINDOWS` The value indicating the Windows operating system.
`static int`	`RI` Ring indicator mask bit constant for UART control line.
`static int`	`RTS` Request to send mask bit constant for UART control line.

Constructor Summary

Constructors
Constructor and Description
`SerialComManager()` Allocates a new SerialComManager object.
`SerialComManager(String directoryPath, String loadedLibName)` Allocates a new SerialComManager object.

Method Summary

Methods
Modifier and Type	Method and Description
`boolean`	`clearPortIOBuffers(long handle, boolean clearRxBuffer, boolean clearTxBuffer)` Discards data sent to port but not transmitted, or data received but not read.
`boolean`	`closeComPort(long handle)` Close the serial port.
`boolean`	`configureComPortControl(long handle, SerialComManager.FLOWCONTROL flowctrl, char xon, char xoff, boolean ParFraError, boolean overFlowErr)` This method configures the way data communication will be controlled between DTE and DCE.
`boolean`	`configureComPortData(long handle, SerialComManager.DATABITS dataBits, SerialComManager.STOPBITS stopBits, SerialComManager.PARITY parity, SerialComManager.BAUDRATE baudRate, int custBaud)` This method configures the rate at which communication will occur and the format of UART frame.
`long`	`createBlockingIOContext()` Prepares a context that should be passed to readBytesBlocking, writeBytesBlocking, readBytes, unblockBlockingIOOperation and destroyBlockingIOContext methods.
`SerialComInByteStream`	`createInputByteStream(long handle, SerialComManager.SMODE streamMode)` Prepares context and returns an input streams of bytes for receiving data bytes from the serial port.
`SerialComOutByteStream`	`createOutputByteStream(long handle, SerialComManager.SMODE streamMode)` Prepares context and returns an output streams of bytes for transferring data bytes out of serial port.
`boolean`	`destroyBlockingIOContext(long context)` Destroys the context that was created by a call to createBlockingIOContext method for blocking I/O operations uses.
`String[]`	`findComPortFromUSBAttributes(int usbVidToMatch, int usbPidToMatch, String serialNumber)` Gives COM port (COMxx/ttySx) of a connected USB-UART device (CDC/ACM Interface) assigned by operating system.
`String`	`findDriverServingComPort(String comPortName)` Gives the name of the driver who is driving the given serial port.
`String`	`findIRQnumberForComPort(long handle)` Gives the address and IRQ number associated with the given serial port.
`boolean`	`fineTuneReadBehaviour(long handle, int vmin, int vtime, int rit, int rttm, int rttc)` This method gives more fine tune control to application for tuning performance and behavior of read operations to leverage OS specific facility for read operation.
`int[]`	`getByteCountInPortIOBuffer(long handle)` Get number of bytes in input and output port buffers used by operating system for instance tty buffers in Unix like systems.
`int`	`getCPUArchitecture()` Gives CPU/Platform architecture as identified by this library.
`String[]`	`getCurrentConfiguration(long handle)` This method gives currently applicable settings associated with particular serial port.
`int`	`getEventsMask(ISerialComEventListener eventListener)` This method return currently applicable mask for events on serial port.
`int[]`	`getInterruptCount(long handle)` This method gives the number of interrupts on serial line that have occurred.
`SerialComIOCTLExecutor`	`getIOCTLExecutor(long handle)` Prepares context for excuting IOCTL operations on the given port.
`String`	`getLibraryVersions()` Gives library versions of java and native library implementations.
`int[]`	`getLinesStatus(long handle)` Gives status of serial port's control lines as supported by underlying operating system.
`int`	`getOSType()` Gives operating system type as identified by this library.
`String`	`getPortName(long handle)` This method gives the port name with which given handle is associated.
`SerialComBluetooth`	`getSerialComBluetoothInstance(int btStack, String directoryPath, String loadedLibName)` Initialize and return an instance of SerialComBluetooth for the given bluetooth stack.
`SerialComDBRelease`	`getSerialComDBReleaseInstance(String directoryPath, String loadedLibName)` Allocate, initialize and return an instance of SerialComDBRelease class on whom APIs can be called to release COM ports in use.
`SerialComHID`	`getSerialComHIDInstance(int type, String directoryPath, String loadedLibName)` Allocate, initialize and return an instance of requested mode for communication with HID device.
`SerialComToKeyStrokeToApp`	`getSerialComKeyStrokeAppInstance(long handle)`
`SerialComPortMapper`	`getSerialComPortMapperInstance(String directoryPath, String loadedLibName)` Allocate, initialize and return an instance of SerialComPortMapper class on whom APIs can be called to map or unmap a serial port alias.
`SerialComUSB`	`getSerialComUSBInstance()` Get an instance of SerialComUSB class for USB related operations.
`SerialComVendorLib`	`getVendorLibInstance(int vendorLibIdentifier, String libDirectory, String vlibName)` Gives an instance of the class which implements API defined by vendor in their propriety library.
`boolean`	`isUSBDevConnected(int vendorID, int productID, String serialNumber)` Checks whether a particular USB device identified by vendor id, product id and serial number is connected to the system or not.
`String[]`	`listAvailableComPorts()` Returns all available UART style ports available on this system, otherwise an empty array of strings, if no serial style port is found in the system.
`SerialComBluetoothSPPDevNode[]`	`listBTSPPDevNodesWithInfo()` Gives device node, remote bluetooth device address and channel number in use for device nodes which are using the RFCOMM service for emulating serial port over bluetooth.
`SerialComUSBdevice[]`	`listUSBdevicesWithInfo(int vendorFilter)` Returns an array of SerialComUSBdevice class objects containing information about all the USB devices found by this library.
`long`	`openComPort(String portName, boolean enableRead, boolean enableWrite, boolean exclusiveOwnerShip)` Opens a serial port for communication.
`boolean`	`pauseListeningEvents(ISerialComEventListener eventListener)` This pauses delivering events to application.
`byte[]`	`readBytes(long handle)` If user does not specify any count, library try to read DEFAULT_READBYTECOUNT (1024 bytes) bytes as default value.
`int`	`readBytes(long handle, byte[] buffer, int offset, int length, long context)` Reads data bytes from serial port into given buffer.
`byte[]`	`readBytes(long handle, int byteCount)` Read specified number of bytes from given serial port.
`byte[]`	`readBytesBlocking(long handle, int byteCount, long context)` Read specified number of bytes from given serial port and stay blocked till bytes arrive at serial port.
`int`	`readBytesDirect(long handle, ByteBuffer buffer, int offset, int length)` Reads the bytes from the serial port into the given direct byte buffer using facilities of the underlying JVM and operating system.
`byte[]`	`readSingleByte(long handle)` This is a utility method to read a single byte from serial port.
`String`	`readString(long handle)` This method reads data from serial port and converts it into string.
`String`	`readString(long handle, int byteCount)` This method reads data from serial port and converts it into string.
`boolean`	`receiveFile(long handle, File fileToReceive, SerialComManager.FTPPROTO ftpProto, SerialComManager.FTPVAR ftpVariant, boolean textMode, ISerialComXmodemProgress progressListener, SerialComXModemAbort transferState)` Receives file using specified file transfer protocol.
`boolean`	`registerDataListener(long handle, ISerialComDataListener dataListener)` This method associate a data looper with the given listener.
`boolean`	`registerLineEventListener(long handle, ISerialComEventListener eventListener)` This method associate a event looper with the given listener.
`int`	`registerUSBHotPlugEventListener(ISerialComUSBHotPlugListener hotPlugListener, int filterVID, int filterPID, String serialNumber)` This registers a listener who will be invoked whenever a USB device has been plugged or un-plugged in system.
`boolean`	`resumeListeningEvents(ISerialComEventListener eventListener)` Resume delivering events kept in queue to application.
`boolean`	`sendBreak(long handle, int duration)` Assert a break condition on the specified port for the duration expressed in milliseconds.
`boolean`	`sendFile(long handle, File fileToSend, SerialComManager.FTPPROTO ftpProto, SerialComManager.FTPVAR ftpVariant, boolean textMode, ISerialComXmodemProgress progressListener, SerialComXModemAbort transferState)` Send given file using specified file transfer protocol.
`boolean`	`setDTR(long handle, boolean enabled)` This method assert/de-assert DTR line of serial port.
`boolean`	`setEventsMask(ISerialComEventListener eventListener, int newMask)` Defines for which line events registered event listener will be called.
`boolean`	`setRTS(long handle, boolean enabled)` This method assert/de-assert RTS line of serial port.
`boolean`	`unblockBlockingIOOperation(long context)` Unblocks any blocked operation if it exist.
`boolean`	`unregisterDataListener(long handle, ISerialComDataListener dataListener)` This method destroys complete java and native looper subsystem associated with this particular data listener.
`boolean`	`unregisterLineEventListener(long handle, ISerialComEventListener eventListener)` This method destroys complete java and native looper subsystem associated with this particular event listener.
`boolean`	`unregisterUSBHotPlugEventListener(int opaqueHandle)` This unregisters listener and terminate native thread used for monitoring specified USB device insertion or removal.
`boolean`	`writeBytes(long handle, byte[] buffer)` Utility method to call writeBytes without delay between successive bytes.
`boolean`	`writeBytes(long handle, byte[] buffer, int delay)` This method writes bytes from the specified byte type buffer.
`boolean`	`writeBytesBlocking(long handle, byte[] buffer, long context)` Write bytes from given buffer to the given handle in blocking mode.
`int`	`writeBytesDirect(long handle, ByteBuffer buffer, int offset, int length)` Writes the bytes from the given direct byte buffer using facilities of the underlying JVM and operating system.
`boolean`	`writeIntArray(long handle, int[] buffer, int delay, SerialComManager.ENDIAN endianness, SerialComManager.NUMOFBYTES numOfBytes)` This method send an array of integers on the specified port.
`boolean`	`writeSingleByte(long handle, byte dataByte)` This method writes a single byte to the specified port.
`boolean`	`writeSingleInt(long handle, int data, int delay, SerialComManager.ENDIAN endianness, SerialComManager.NUMOFBYTES numOfBytes)` Different CPU and OS will have different endianness.
`boolean`	`writeString(long handle, String data, Charset charset, int delay)` This method writes a string to the specified port.
`boolean`	`writeString(long handle, String data, int delay)` This method writes a string to the specified port.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - JAVA_LIB_VERSION
```
public static final String JAVA_LIB_VERSION
```
    Production release version of the serial communication manager library.
    
    See Also:
    Constant Field Values
  - OS_UNKNOWN
```
public static final int OS_UNKNOWN
```
    The value indicating that operating system is unknown to SCM library. Integer constant with value 0x00.
    
    See Also:
    Constant Field Values
  - OS_LINUX
```
public static final int OS_LINUX
```
    The value indicating the Linux operating system. Integer constant with value 0x01.
    
    See Also:
    Constant Field Values
  - OS_WINDOWS
```
public static final int OS_WINDOWS
```
    The value indicating the Windows operating system. Integer constant with value 0x02.
    
    See Also:
    Constant Field Values
  - OS_SOLARIS
```
public static final int OS_SOLARIS
```
    The value indicating the Solaris operating system. Integer constant with value 0x03.
    
    See Also:
    Constant Field Values
  - OS_MAC_OS_X
```
public static final int OS_MAC_OS_X
```
    The value indicating the Mac OS X operating system. Integer constant with value 0x04.
    
    See Also:
    Constant Field Values
  - OS_FREEBSD
```
public static final int OS_FREEBSD
```
    The value indicating the FreeBSD operating system.. Integer constant with value 0x05.
    
    See Also:
    Constant Field Values
  - OS_NETBSD
```
public static final int OS_NETBSD
```
    The value indicating the NetBSD operating system. Integer constant with value 0x06.
    
    See Also:
    Constant Field Values
  - OS_OPENBSD
```
public static final int OS_OPENBSD
```
    The value indicating the OpenBSD operating system. Integer constant with value 0x07.
    
    See Also:
    Constant Field Values
  - OS_IBM_AIX
```
public static final int OS_IBM_AIX
```
    The value indicating the IBM AIX operating system. Integer constant with value 0x08.
    
    See Also:
    Constant Field Values
  - OS_HP_UX
```
public static final int OS_HP_UX
```
    The value indicating the HP-UX operating system. Integer constant with value 0x09.
    
    See Also:
    Constant Field Values
  - OS_ANDROID
```
public static final int OS_ANDROID
```
    The value indicating the Android operating system. Integer constant with value 0x0A.
    
    See Also:
    Constant Field Values
  - ARCH_UNKNOWN
```
public static final int ARCH_UNKNOWN
```
    The value indicating that platform architecture is unknown to SCM library. Integer constant with value 0x00.
    
    See Also:
    Constant Field Values
  - ARCH_X86
```
public static final int ARCH_X86
```
    The common value indicating that the library is running on a 32 bit Intel i386/i486/i586/i686/i786/i886/i986/IA-32 based architecture. Integer constant with value 0x01.
    
    See Also:
    Constant Field Values
  - ARCH_AMD64
```
public static final int ARCH_AMD64
```
    The common value indicating that the library is running on a 64 bit Intel x86_64 (x86-64/x64/Intel 64) and AMD amd64 based architecture. Integer constant with value 0x02.
    
    See Also:
    Constant Field Values
  - ARCH_IA64
```
public static final int ARCH_IA64
```
    The value indicating that the library is running on a 64 bit Intel/HP Itanium based architecture. Integer constant with value 0x03.
    
    See Also:
    Constant Field Values
  - ARCH_IA64_32
```
public static final int ARCH_IA64_32
```
    The value indicating that the library is running on an IA64 32 bit based architecture. Integer constant with value 0x04.
    
    See Also:
    Constant Field Values
  - ARCH_PPC32
```
public static final int ARCH_PPC32
```
    The value indicating that the library is running on a 32 bit PowerPC based architecture from Apple–IBM–Motorola. Integer constant with value 0x05.
    
    See Also:
    Constant Field Values
  - ARCH_PPC64
```
public static final int ARCH_PPC64
```
    The value indicating that the library is running on a 64 bit PowerPC based architecture from Apple–IBM–Motorola. Integer constant with value 0x06.
    
    See Also:
    Constant Field Values
  - ARCH_PPC64LE
```
public static final int ARCH_PPC64LE
```
    The value indicating that the library is running on a 64 bit PowerPC based architecture in little endian mode from Apple–IBM–Motorola. Integer constant with value 0x06.
    
    See Also:
    Constant Field Values
  - ARCH_SPARC32
```
public static final int ARCH_SPARC32
```
    The value indicating that the library is running on a 32 bit Sparc based architecture from Sun Microsystems. Integer constant with value 0x07.
    
    See Also:
    Constant Field Values
  - ARCH_SPARC64
```
public static final int ARCH_SPARC64
```
    The value indicating that the library is running on a 64 bit Sparc based architecture from Sun Microsystems. Integer constant with value 0x08.
    
    See Also:
    Constant Field Values
  - ARCH_PA_RISC32
```
public static final int ARCH_PA_RISC32
```
    The value indicating that the library is running on a 32 bit PA-RISC based architecture. Integer constant with value 0x09.
    
    See Also:
    Constant Field Values
  - ARCH_PA_RISC64
```
public static final int ARCH_PA_RISC64
```
    The value indicating that the library is running on a 64 bit PA-RISC based architecture. Integer constant with value 0x0A.
    
    See Also:
    Constant Field Values
  - ARCH_S390
```
public static final int ARCH_S390
```
    The value indicating that the library is running on a 32 bit IBM S/390 system. Integer constant with value 0x0B.
    
    See Also:
    Constant Field Values
  - ARCH_S390X
```
public static final int ARCH_S390X
```
    The value indicating that the library is running on a 64 bit IBM S/390 system. Integer constant with value 0x0C.
    
    See Also:
    Constant Field Values
  - ARCH_ARMV5
```
public static final int ARCH_ARMV5
```
    The value indicating that the library is running on a ARMv5 based architecture CPU. Integer constant with value 0x0D.
    
    See Also:
    Constant Field Values
  - ARCH_ARMV6
```
public static final int ARCH_ARMV6
```
    The value indicating that the library is running on a ARMv6 soft float based JVM. Integer constant with value 0x0E.
    
    See Also:
    Constant Field Values
  - ARCH_ARMV7
```
public static final int ARCH_ARMV7
```
    The value indicating that the library is running on a ARMv7 soft float based JVM. Integer constant with value 0x10.
    
    See Also:
    Constant Field Values
  - ABI_ARMHF
```
public static final int ABI_ARMHF
```
    The value indicating hard float ABI.
    
    See Also:
    Constant Field Values
  - ABI_ARMEL
```
public static final int ABI_ARMEL
```
    The value indicating soft float ABI.
    
    See Also:
    Constant Field Values
  - DEFAULT_READBYTECOUNT
```
public static final int DEFAULT_READBYTECOUNT
```
    Default number of bytes (1024) to read from serial port.
    
    See Also:
    Constant Field Values
  - CTS
```
public static final int CTS
```
    Clear to send mask bit constant for UART control line.
    
    See Also:
    Constant Field Values
  - DSR
```
public static final int DSR
```
    Data set ready mask bit constant for UART control line.
    
    See Also:
    Constant Field Values
  - DCD
```
public static final int DCD
```
    Data carrier detect mask bit constant for UART control line.
    
    See Also:
    Constant Field Values
  - RI
```
public static final int RI
```
    Ring indicator mask bit constant for UART control line.
    
    See Also:
    Constant Field Values
  - LOOP
```
public static final int LOOP
```
    Loop indicator mask bit constant for UART control line.
    
    See Also:
    Constant Field Values
  - RTS
```
public static final int RTS
```
    Request to send mask bit constant for UART control line.
    
    See Also:
    Constant Field Values
  - DTR
```
public static final int DTR
```
    Data terminal ready mask bit constant for UART control line.
    
    See Also:
    Constant Field Values
  - EXP_UNBLOCKIO
```
public static final String EXP_UNBLOCKIO
```
    The exception message indicating that a blocked read method has been unblocked and made to return to caller explicitly (irrespective there was data to read or not).
    
    See Also:
    Constant Field Values
- Constructor Detail
  - SerialComManager
```
public SerialComManager()
                 throws SecurityException,
                        SerialComUnexpectedException,
                        SerialComLoadException,
                        UnsatisfiedLinkError,
                        SerialComException,
                        FileNotFoundException,
                        IOException
```
    Allocates a new SerialComManager object. Identify operating system type, CPU architecture, prepares environment required for running this library, initiates extraction and loading of native libraries.
    
    The native shared library will be extracted in folder named 'scm_tuartx1' inside system/user 'temp' folder or user home folder if access to 'temp' folder is denied.
    
    Throws:
    
    SecurityException - if java system properties can not be accessed.
    
    SerialComUnexpectedException - if java system property is null.
    
    SerialComLoadException - if any file system related issue occurs.
    
    UnsatisfiedLinkError - if loading/linking shared library fails.
    
    FileNotFoundException - if file "/proc/cpuinfo" can not be found for Linux on ARM platform.
    
    IOException - if file operations on "/proc/cpuinfo" fails for Linux on ARM platform.
    
    SerialComException - if initializing native library fails.
  - SerialComManager
```
public SerialComManager(String directoryPath,
                String loadedLibName)
                 throws SecurityException,
                        SerialComUnexpectedException,
                        SerialComLoadException,
                        UnsatisfiedLinkError,
                        SerialComException,
                        FileNotFoundException,
                        IOException
```
    Allocates a new SerialComManager object. Identify operating system type, CPU architecture, prepares environment required for running this library, initiates extraction and loading of native libraries.
    
    It extracts native shared library in the folder specified by argument directoryPath and gives library name specified by loadedLibName. This helps in increasing isolation as completely independent applications might also be using this library. Using different folders make sure that independent applications unaware if each other does not override shared library file in file system.
    
    This also increase security as the folder may be given specific user permissions.
    
    Parameters:
    directoryPath - absolute path of directory for extraction.
    loadedLibName - library name without extension (do not append .so, .dll or .dylib etc.).
    
    Throws:
    
    SecurityException - if java system properties can not be accessed.
    
    SerialComUnexpectedException - if java system property is null.
    
    SerialComLoadException - if any file system related issue occurs.
    
    UnsatisfiedLinkError - if loading/linking shared library fails.
    
    FileNotFoundException - if file "/proc/cpuinfo" can not be found for Linux on ARM platform.
    
    IOException - if file operations on "/proc/cpuinfo" fails for Linux on ARM platform.
    
    SerialComException - if initializing native library fails.
    
    IllegalArgumentException - if directoryPath is null, directoryPath is empty, loadedLibName is null or empty.
- Method Detail
  - getLibraryVersions
```
public String getLibraryVersions()
                          throws SerialComException
```
    Gives library versions of java and native library implementations.
    
    Returns:
    Java and C library versions implementing this library.
    
    Throws:
    
    SerialComException - if native library version could not be determined.
  - getOSType
```
public int getOSType()
```
    Gives operating system type as identified by this library. To interpret returned integer value see the OS_xxxxx defined in SerialComManager class.
    
    This method may be used to develop application with consistent behavior across different operating systems. For example let us assume that in a poll based application calling Thread.sleep(10) make ~10 milliseconds sleep in Linux operating system but causes ~50 milliseconds sleep in Windows because these operating system may have different resolution for sleep timings. To deal with this write the application code in following manner :
```
 int osType = scm.getOSType();
 if(osType == SerialComManager.OS_LINUX) {
 	Thread.sleep(10);
 }else if(osType == SerialComManager.OS_WINDOWS) {
 	Thread.sleep(1);
 }else {
 	Thread.sleep(5);
 }
 
```
    Returns:
    one of the constants OS_xxxxx defined in SerialComManager class.
  - getCPUArchitecture
```
public int getCPUArchitecture()
```
    Gives CPU/Platform architecture as identified by this library. To interpret return integer see constants defined SerialComManager class.
    
    Returns:
    CPU/Platform architecture as identified by the scm library.
  - listAvailableComPorts
```
public String[] listAvailableComPorts()
                               throws SerialComException
```
    Returns all available UART style ports available on this system, otherwise an empty array of strings, if no serial style port is found in the system.
    
    This should find regular UART ports, hardware/software virtual COM ports, port server, USB-UART converter, bluetooth/3G dongles, ports connected through USB hub/expander, serial card, serial controller, pseudo terminals, printers and virtual modems etc.
    
    This method may be used to find valid serial ports for communications before opening them for writing more robust application.
    
    Note : The BIOS may ignore UART ports on a PCI card and therefore BIOS settings has to be corrected if you modified default BIOS in OS.
    
    Returns:
    Available UART style ports name for windows, full path with name for Unix like OS, returns empty array if no ports found.
    
    Throws:
    
    SerialComException - if an I/O error occurs.
  - listUSBdevicesWithInfo
```
public SerialComUSBdevice[] listUSBdevicesWithInfo(int vendorFilter)
                                            throws SerialComException
```
    Returns an array of SerialComUSBdevice class objects containing information about all the USB devices found by this library. Application can call various methods on SerialComUSBdevice object to get specific information like vendor id and product id etc. The GUI applications may display a dialogue box asking user to connect the end product if the desired product is still not connected to system.
    
    The USB vendor id, USB product id, serial number, product name and manufacturer information is encapsulated in the object of class SerialComUSBdevice returned.
    
    Some USB-UART chip manufactures may give some unique USB PID(s) to end product manufactures at minimal or no cost. Applications written for these end products may be interested in finding devices only from the USB-UART chip manufacturer. For example, an application built for finger print scanner based on FT232 IC will like to list only those devices whose VID matches VID of FTDI. Then further application may verify PID by calling methods on the USBDevice object. For this purpose argument vendorFilter may be used.
    
    Parameters:
    vendorFilter - vendor whose devices should be listed (one of the constants SerialComUSB.V_xxxxx or any valid USB VID).
    
    Returns:
    list of the USB devices with information about them or empty array if no device matching given criteria found.
    
    Throws:
    
    SerialComException - if an I/O error occurs.
    
    IllegalArgumentException - if vendorFilter is negative or invalid number.
  - findComPortFromUSBAttributes
```
public String[] findComPortFromUSBAttributes(int usbVidToMatch,
                                    int usbPidToMatch,
                                    String serialNumber)
                                      throws SerialComException
```
    Gives COM port (COMxx/ttySx) of a connected USB-UART device (CDC/ACM Interface) assigned by operating system.
    
    Assume a bar code scanner using FTDI chip FT232R is to be used by application at point of sale. First we need to know whether it is connect to system or not. This can be done using listUSBdevicesWithInfo() or by using USB hot plug listener depending upon application design.
    
    Once it is known that the device is connected to system, we application need to open it. For this, application needs to know the COM port number or device node corresponding to the scanner. It is for this purpose this method can be used.
    
    Another use case of this API is to align application design with true spirit of USB hot plugging in operating system. When a USB-UART device is connected, OS may assign different COM port number or device node to the same device depending upon system scenario. Generally we need to write custom udev rules so that device node will be same. Using this API this limitation can be overcome.
    The reason why this method returns array instead of string is that two or more USB-UART converters connected to system might have exactly same USB attributes. So this will list COM ports assigned to all of them.
    
    Parameters:
    usbVidToMatch - USB vendor id of the device to match.
    usbPidToMatch - USB product id of the device to match.
    serialNumber - USB serial number (case insensitive, optional) of device to match or null if not to be matched.
    
    Returns:
    list of COM port(s) (device node) for given USB device or empty array if no COM port is assigned.
    
    Throws:
    
    SerialComException - if an I/O error occurs.
    
    IllegalArgumentException - if usbVidToMatch or usbPidToMatch is negative or or invalid number.
  - listBTSPPDevNodesWithInfo
```
public SerialComBluetoothSPPDevNode[] listBTSPPDevNodesWithInfo()
                                                         throws SerialComException
```
    Gives device node, remote bluetooth device address and channel number in use for device nodes which are using the RFCOMM service for emulating serial port over bluetooth.
    
    Returns:
    list of the BT SPP device node(s) with information about them or empty array if no device node is found.
    
    Throws:
    
    SerialComException - if an I/O error occurs.
  - openComPort
```
public long openComPort(String portName,
               boolean enableRead,
               boolean enableWrite,
               boolean exclusiveOwnerShip)
                 throws SerialComException
```
    Opens a serial port for communication. If an attempt is made to open a port which is already opened exception in throw.
    - For Linux and Mac OS X, if exclusiveOwnerShip is true, before this method return, the caller will either be exclusive owner or not. If the caller is successful in becoming exclusive owner than all the attempt to open the same port again will cause native code to return error. Note that a root owned process (root user) will still be able to open the port.
      For Windows the exclusiveOwnerShip must be true as it does not allow sharing COM ports. An exception is thrown if exclusiveOwnerShip is set to false.
      
      For Solaris, exclusiveOwnerShip should be set to false as of now.
    - When the serial port is opened DTR and RTS lines will be raised by default. Sometimes, DTR acts as a modem on-hook/off-hook control for other end. Modern modems are highly flexible in their dependency, working and configurations. It is best to consult modem manual. If the application design need DTR/RTS not to be asserted when port is opened custom drivers can be used or hardware can be modified for this purpose. Alternatively, if the application is to be run on Windows operating system only, then modifying INF file or registry key may help in not raising DTR/RTS when port is opened. Typically in Windows DTR/RTS is raised due to enumeration sequence (serenum).
    This method is thread safe.
    Parameters:
    portName - name of the port to be opened for communication.
    enableRead - allows application to read bytes from this port.
    enableWrite - allows application to write bytes to this port.
    exclusiveOwnerShip - application wants to become exclusive owner of this port or not.
    
    Returns:
    handle of the port successfully opened.
    
    Throws:
    
    SerialComException - if trying to become exclusive owner when port is already opened.
    
    IllegalArgumentException - if portName is null or invalid length, or if both enableRead and enableWrite are set to false, if trying to open port in Windows without being exclusive owner.
  - closeComPort
```
public boolean closeComPort(long handle)
                     throws SerialComException
```
    Close the serial port. Application should unregister listeners if it has registered any before calling this method.
    
    DTR line is dropped when port is closed.
    
    This method is thread safe.
    
    Parameters:
    handle - of the port to be closed.
    
    Returns:
    Return true if the serial port is closed.
    
    Throws:
    
    SerialComException - if invalid handle is passed or when it fails in closing the port.
    
    IllegalStateException - if application tries to close port while data/event listeners, or input/output byte streams exist.
  - writeBytes
```
public boolean writeBytes(long handle,
                 byte[] buffer,
                 int delay)
                   throws SerialComException
```
    This method writes bytes from the specified byte type buffer. If the method returns false, the application should try to re-send bytes. The data has been transmitted out of serial port when this method returns.
    
    If large amount of data need to be written, consider breaking it into chunks of data of size for example 2KB each.
    
    Writing empty buffer i.e. zero length array is not allowed.
    
    It should be noted that on Linux system reading from the terminal after a disconnect causes an end-of-file condition, and writing causes an EIO error to be returned. The terminal device must be closed and reopened to clear the condition.
    
    Parameters:
    handle - handle of the opened port on which to write bytes.
    buffer - byte type buffer containing bytes to be written to port.
    delay - time gap between transmitting two successive bytes.
    
    Returns:
    true on success, false on failure or if empty buffer is passed.
    
    Throws:
    
    SerialComException - if an I/O error occurs.
    
    IllegalArgumentException - if buffer is null or delay is negative.
  - writeBytes
```
public boolean writeBytes(long handle,
                 byte[] buffer)
                   throws SerialComException
```
    Utility method to call writeBytes without delay between successive bytes.
    
    The writeBytes(handle, buffer) method for class SerialComManager has the same effect as:
    
    writeBytes(handle, buffer, 0)
    
    Parameters:
    handle - handle of the opened port on which to write bytes.
    buffer - byte type buffer containing bytes to be written to port.
    
    Returns:
    true on success, false on failure or if empty buffer is passed.
    
    Throws:
    
    SerialComException - if an I/O error occurs.
    
    IllegalArgumentException - if buffer is null.
  - writeSingleByte
```
public boolean writeSingleByte(long handle,
                      byte dataByte)
                        throws SerialComException
```
    This method writes a single byte to the specified port. The data has been transmitted out of serial port when this method returns.
    
    Parameters:
    handle - handle of the opened port on which to write byte.
    dataByte - byte to be written to port.
    
    Returns:
    true on success.
    
    Throws:
    
    SerialComException - if an I/O error occurs.
  - writeString
```
public boolean writeString(long handle,
                  String data,
                  int delay)
                    throws SerialComException
```
    This method writes a string to the specified port. The library internally converts string to byte buffer. The data has been transmitted out of serial port when this method returns.
    
    Parameters:
    handle - handle of the opened port on which to write byte.
    data - the string to be send to port.
    delay - interval between two successive bytes while sending string.
    
    Returns:
    true on success false otherwise.
    
    Throws:
    
    SerialComException - if an I/O error occurs.
    
    IllegalArgumentException - if data is null.
  - writeString
```
public boolean writeString(long handle,
                  String data,
                  Charset charset,
                  int delay)
                    throws UnsupportedEncodingException,
                           SerialComException
```
    This method writes a string to the specified port. The library internally converts string to byte buffer. The data has been transmitted out of serial port when this method returns.
    
    Parameters:
    handle - handle of the opened port on which to write byte.
    data - the string to be send to port.
    charset - the character set into which given string will be encoded.
    delay - time gap between transmitting two successive bytes in this string.
    
    Returns:
    true on success false otherwise.
    
    Throws:
    
    SerialComException - if an I/O error occurs.
    
    IllegalArgumentException - if data is null.
    
    UnsupportedEncodingException
  - writeSingleInt
```
public boolean writeSingleInt(long handle,
                     int data,
                     int delay,
                     SerialComManager.ENDIAN endianness,
                     SerialComManager.NUMOFBYTES numOfBytes)
                       throws SerialComException
```
    Different CPU and OS will have different endianness. It is therefore we handle the endianness conversion as per the requirement. If the given integer is in range −32,768 to 32,767, only two bytes will be needed. In such case we might like to send only 2 bytes to serial port. On the other hand application might be implementing some custom protocol so that the data must be 4 bytes (irrespective of its range) in order to be interpreted correctly by the receiver terminal. This method assumes that integer value can be represented by 32 or less number of bits. On x86_64 architecture, loss of precision will occur if the integer value is of more than 32 bit.
    
    The data has been transmitted physically out of serial port when this method returns.
    
    In java numbers are represented in 2's complement, so number 650 whose binary representation is 0000001010001010 is printed byte by byte, then will be printed as 1 and -118, because 10001010 in 2's complement is negative number.
    
    Parameters:
    handle - handle of the opened port on which to write byte.
    data - an integer number to be sent to port.
    delay - interval between two successive bytes .
    endianness - big or little endian sequence to be followed while sending bytes representing this integer.
    numOfBytes - number of bytes this integer can be represented in.
    
    Returns:
    true on success false otherwise.
    
    Throws:
    
    SerialComException - if an I/O error occurs.
    
    IllegalArgumentException - if endianness or numOfBytes is null.
  - writeIntArray
```
public boolean writeIntArray(long handle,
                    int[] buffer,
                    int delay,
                    SerialComManager.ENDIAN endianness,
                    SerialComManager.NUMOFBYTES numOfBytes)
                      throws SerialComException
```
    This method send an array of integers on the specified port. The data has been transmitted out of serial port when this method returns.
    
    Parameters:
    handle - handle of the opened port on which to write byte.
    buffer - an array of integers to be sent to port.
    delay - interval between two successive bytes .
    endianness - big or little endian sequence to be followed while sending bytes representing this integer.
    numOfBytes - number of bytes this integer can be represented in.
    
    Returns:
    true on success false otherwise.
    
    Throws:
    
    SerialComException - if an I/O error occurs.
    
    IllegalArgumentException - if endianness or numOfBytes is null.
  - writeBytesDirect
```
public int writeBytesDirect(long handle,
                   ByteBuffer buffer,
                   int offset,
                   int length)
                     throws SerialComException
```
    Writes the bytes from the given direct byte buffer using facilities of the underlying JVM and operating system. When this method returns data would have sent out of serial port physically.
    
    Consider using this method when developing applications based on Bluetooth serial port profile or applications like printing document using printer.
    
    This method does not modify the direct byte buffer attributes position, capacity, limit and mark. The application design is expected to take care of this as and when required in appropriate manner. Further, this method does not consume or modify the data in the given buffer.
    
    Parameters:
    handle - handle of the serial port on which to write bytes.
    buffer - direct byte buffer containing bytes to be written to port.
    offset - location from where to start sending data out of serial port.
    length - number of bytes from offset to sent to serial port.
    
    Returns:
    number of bytes sent to serial port, 0 if length is 0.
    
    Throws:
    
    SerialComException - if an I/O error occurs.
    
    IllegalArgumentException - if buffer is null, or if position or limit is negative, or if given buffer is not direct byte buffer, or if length > (buffer.capacity() - offset).
  - writeBytesBlocking
```
public boolean writeBytesBlocking(long handle,
                         byte[] buffer,
                         long context)
                           throws SerialComException
```
    Write bytes from given buffer to the given handle in blocking mode.
    
    Writing empty buffer i.e. zero length array is not allowed.
    
    Parameters:
    handle - handle of the opened port on which to write bytes.
    buffer - byte type buffer containing bytes to be written to port.
    context - context value obtained form call to createBlockingIOContext method.
    
    Returns:
    true on success, false on failure or if empty buffer is passed.
    
    Throws:
    
    SerialComException - if an I/O error occurs.
    
    IllegalArgumentException - if buffer is null.
  - readBytesDirect
```
public int readBytesDirect(long handle,
                  ByteBuffer buffer,
                  int offset,
                  int length)
                    throws SerialComException
```
    Reads the bytes from the serial port into the given direct byte buffer using facilities of the underlying JVM and operating system.
    
    This method does not modify the direct byte buffer attributes position, capacity, limit and mark. The application design is expected to take care of this as and when required in appropriate manner.
    
    Parameters:
    handle - handle of the serial port from which to read data bytes.
    buffer - direct byte buffer into which data bytes will be placed.
    offset - location in byte buffer from which to start saving data.
    length - number of bytes from offset to read in buffer.
    
    Returns:
    number of bytes read from serial port, 0 if length is 0.
    
    Throws:
    
    SerialComException - if an I/O error occurs.
    
    IllegalArgumentException - if buffer is null, or if position or limit is negative, or if given buffer is not direct byte buffer.
  - createBlockingIOContext
```
public long createBlockingIOContext()
                             throws SerialComException
```
    Prepares a context that should be passed to readBytesBlocking, writeBytesBlocking, readBytes, unblockBlockingIOOperation and destroyBlockingIOContext methods.
    
    Returns:
    context value that should be passed to destroyBlockingIOContext, readBytesBlocking and writeBytesBlocking methods.
    
    Throws:
    
    SerialComException - if an I/O error occurs.
  - unblockBlockingIOOperation
```
public boolean unblockBlockingIOOperation(long context)
                                   throws SerialComException
```
    Unblocks any blocked operation if it exist. This causes closing of serial port possible gracefully and return the worker thread that called blocking read/write to return and proceed as per application design.
    
    Parameters:
    context - context obtained from call to createBlockingIOContext method for blocking I/O operations.
    
    Returns:
    true if blocked operation was unblocked successfully.
    
    Throws:
    
    SerialComException - if an I/O error occurs.
  - destroyBlockingIOContext
```
public boolean destroyBlockingIOContext(long context)
                                 throws SerialComException
```
    Destroys the context that was created by a call to createBlockingIOContext method for blocking I/O operations uses.
    
    Parameters:
    context - context obtained from call to createBlockingIOContext method for blocking I/O operations.
    
    Returns:
    true if the context gets destroyed successfully.
    
    Throws:
    
    SerialComException - if an I/O error occurs.
  - readBytesBlocking
```
public byte[] readBytesBlocking(long handle,
                       int byteCount,
                       long context)
                         throws SerialComException
```
    Read specified number of bytes from given serial port and stay blocked till bytes arrive at serial port.
    
    1. If data is read from serial port, array of bytes containing data is returned.
    
    2. If there was no data in serial port to read, null is returned. Note that this case is not possible however for blocking read call.
    
    The number of bytes to read must be greater than or equal to 1 and less than or equal to 2048 (1 <= byteCount <= 2048). This method may return less than the requested number of bytes due to reasons like, there is less data in operating system buffer (serial port) or operating system returned less data which is also legal.
    
    Application must catch exception thrown by this method. When this method returns and exception with message SerialComManager.EXP_UNBLOCKIO is thrown, it indicates that the blocked read method was explicitly unblocked by another thread (possibly because serial port is going to be closed).
    
    Parameters:
    handle - of the serial port from which to read bytes.
    byteCount - number of bytes to read from serial port.
    context - context obtained by a call to createBlockingIOContext method.
    
    Returns:
    array of bytes read from port or null.
    
    Throws:
    
    SerialComException - if an I/O error occurs or if byteCount is greater than 2048.
  - readBytes
```
public byte[] readBytes(long handle,
               int byteCount)
                 throws SerialComException
```
    Read specified number of bytes from given serial port.
    
    1. If data is read from serial port, array of bytes containing data is returned.
    
    2. If there was no data in serial port to read, null is returned.
    
    The number of bytes to read must be greater than or equal to 1 and less than or equal to 2048 (1 <= byteCount <= 2048). This method may return less than the requested number of bytes due to reasons like, there is less data in operating system buffer (serial port) or operating system returned less data which is also legal.
    
    Parameters:
    handle - of the serial port from which to read bytes.
    byteCount - number of bytes to read from serial port.
    
    Returns:
    array of bytes read from port or null.
    
    Throws:
    
    SerialComException - if an I/O error occurs or if byteCount is greater than 2048.
  - readBytes
```
public byte[] readBytes(long handle)
                 throws SerialComException
```
    If user does not specify any count, library try to read DEFAULT_READBYTECOUNT (1024 bytes) bytes as default value.
    
    It has same effect as readBytes(handle, 1024)
    
    Parameters:
    handle - of the port from which to read bytes.
    
    Returns:
    array of bytes read from port or null.
    
    Throws:
    
    SerialComException - if an I/O error occurs.
  - readString
```
public String readString(long handle,
                int byteCount)
                  throws SerialComException
```
    This method reads data from serial port and converts it into string.
    
    It Constructs a new string by decoding the specified array of bytes using the platform's default charset. The length of the new string is a function of the charset, and hence may not be equal to the length of the byte array read from serial port.
    
    Parameters:
    handle - of port from which to read bytes.
    byteCount - number of bytes to read from this port.
    
    Returns:
    string constructed from data read from serial port or null.
    
    Throws:
    
    SerialComException - if an I/O error occurs or if byteCount is greater than 2048.
  - readString
```
public String readString(long handle)
                  throws SerialComException
```
    This method reads data from serial port and converts it into string.
    
    It Constructs a new string by decoding the specified array of bytes using the platform's default charset. The length of the new string is a function of the charset, and hence may not be equal to the length of the byte array read from serial port.
    
    Note that the length of data bytes read using this method can not be greater than DEFAULT_READBYTECOUNT i.e. 1024.
    
    Parameters:
    handle - of the port from which to read bytes.
    
    Returns:
    string constructed from data read from serial port or null.
    
    Throws:
    
    SerialComException - if an I/O error occurs.
  - readSingleByte
```
public byte[] readSingleByte(long handle)
                      throws SerialComException
```
    This is a utility method to read a single byte from serial port.
    
    Its effect is same as readBytes(handle, 1)
    
    Parameters:
    handle - of the port from which to read byte.
    
    Returns:
    array of length 1 representing 1 byte data read from serial port or null.
    
    Throws:
    
    SerialComException - if an I/O error occurs.
  - readBytes
```
public int readBytes(long handle,
            byte[] buffer,
            int offset,
            int length,
            long context)
              throws SerialComException
```
    Reads data bytes from serial port into given buffer. This method is mainly intended for use in application design which needs to poll serial port continuously for presence of data.
    
    This method can be used in blocking mode or non-blocking mode. If context is -1, this method will not block. For blocking behavior pass context value obtained by call to createBlockingIOContext method. If a valid context is passed, this method will block until there is data to read from serial port.
    
    Application must catch exception thrown by this method if using blocking mode. When this method returns and exception with message SerialComManager.EXP_UNBLOCKIO is thrown, it indicates that the blocked read method was explicitly unblocked by another thread (possibly because serial port is going to be closed).
    
    Parameters:
    handle - of the port from which to read data bytes.
    buffer - data byte buffer in which bytes from serial port will be saved.
    offset - index in given byte array at which first data byte will be placed.
    length - number of bytes to read into given buffer (0 <= length <= 2048).
    context - context obtained by call to createBlockingIOContext method for blocking behavior or -1 for non-blocking behavior.
    
    Returns:
    number of bytes read from serial port.
    
    Throws:
    
    SerialComException - if an I/O error occurs.
    
    NullPointerException - if buffer is null.
    
    IndexOutOfBoundsException - if offset is negative, length is negative, or length is greater than buffer.length - offset.
  - configureComPortData
```
public boolean configureComPortData(long handle,
                           SerialComManager.DATABITS dataBits,
                           SerialComManager.STOPBITS stopBits,
                           SerialComManager.PARITY parity,
                           SerialComManager.BAUDRATE baudRate,
                           int custBaud)
                             throws SerialComException
```
    This method configures the rate at which communication will occur and the format of UART frame. This method must be called before configureComPortControl method.
    
    [1] Most of the DTE/DCE (hardware) does not support different baud rates for transmission and reception and therefore this method takes only single value applicable to both transmission and reception.
    [2] All serial devices/drivers/operating systems does not support all the baud rates (maximum change in signal per second), stop bits, data bits etc. Please consult hardware and software manuals as appropriate.
    [3] If parity is enabled, the parity bit will be removed from UART frame before passing it to this library.
    [4] Some USB-UART devices supports non-standard baudrates. How to set these baudrate is device/driver and operating system specific.
    
    Parameters:
    handle - of opened port to which this configuration applies to.
    dataBits - number of data bits in one frame (refer DATABITS enum in SerialComManager class for this).
    stopBits - number of stop bits in one frame (refer STOPBITS enum in SerialComManager class for this).
    parity - of the frame (refer PARITY enum in SerialComManager class for this).
    baudRate - of the frame (refer BAUDRATE enum in SerialComManager class for this).
    custBaud - custom baudrate if the desired rate is not included in BAUDRATE enum.
    
    Returns:
    true on success false otherwise.
    
    Throws:
    
    SerialComException - if invalid handle is passed or an error occurs in configuring the port.
    
    IllegalArgumentException - if dataBits or stopBits or parity or baudRate is null, or if custBaud is zero or negative.
  - configureComPortControl
```
public boolean configureComPortControl(long handle,
                              SerialComManager.FLOWCONTROL flowctrl,
                              char xon,
                              char xoff,
                              boolean ParFraError,
                              boolean overFlowErr)
                                throws SerialComException
```
    This method configures the way data communication will be controlled between DTE and DCE. This specifies flow control and actions that will be taken when an error is encountered in communication.
    
    Some serial devices does not support some flow controls scheme. Please refer to their manuals.
    
    Parameters:
    handle - of opened port to which need to be configured.
    flowctrl - flow control, how data flow will be controlled (refer FLOWCONTROL enum for this).
    xon - character representing on condition if software flow control is used.
    xoff - character representing off condition if software flow control is used.
    ParFraError - true if parity and frame errors are to be checked false otherwise.
    overFlowErr - true if overflow error is to be detected false otherwise.
    
    Returns:
    true on success false otherwise.
    
    Throws:
    
    SerialComException - if invalid handle is passed or an error occurs in configuring the port.
    
    IllegalArgumentException - if flowctrl is null.
  - getCurrentConfiguration
```
public String[] getCurrentConfiguration(long handle)
                                 throws SerialComException
```
    This method gives currently applicable settings associated with particular serial port. The values are bit mask so that application can manipulate them to get required information.
    
    For Unix-like OS the order is : c_iflag, c_oflag, c_cflag, c_lflag, c_line, c_cc[0], c_cc[1], c_cc[2], c_cc[3] c_cc[4], c_cc[5], c_cc[6], c_cc[7], c_cc[8], c_cc[9], c_cc[10], c_cc[11], c_cc[12], c_cc[13], c_cc[14], c_cc[15], c_cc[16], c_ispeed and c_ospeed.
    
    For Windows OS the order is :DCBlength, BaudRate, fBinary, fParity, fOutxCtsFlow, fOutxDsrFlow, fDtrControl, fDsrSensitivity, fTXContinueOnXoff, fOutX, fInX, fErrorChar, fNull, fRtsControl, fAbortOnError, fDummy2, wReserved, XonLim, XoffLim, ByteSize, Parity, StopBits, XonChar, XoffChar, ErrorChar, StopBits, EvtChar, wReserved1.
    
    Parameters:
    handle - of the opened port.
    
    Returns:
    array of string giving configuration.
    
    Throws:
    
    SerialComException - if invalid handle is passed or an error occurs while reading current settings.
  - setRTS
```
public boolean setRTS(long handle,
             boolean enabled)
               throws SerialComException
```
    This method assert/de-assert RTS line of serial port. Set "true" for asserting signal, false otherwise. This changes the state of RTS line electrically.
    
    RTS and DTR lines can be asserted or de-asserted even when using no flow control on serial port.
    
    The RS-232 standard defines the voltage levels that correspond to logical one and logical zero levels for the data transmission and the control signal lines. Valid signals are either in the range of +3 to +15 volts or the range −3 to −15 volts with respect to the ground/common pin; consequently, the range between −3 to +3 volts is not a valid RS-232 level.
    
    In asserted condition, voltage at pin number 7 (RTS signal) will be greater than 3 volts. Voltage 5.0 volts was observed when using USB-UART converter : http://www.amazon.in/Bafo-USB-Serial-Converter-DB9/dp/B002SCRCDG.
    
    On some hardware IC, signals may be active low and therefore for actual voltage datasheet should be consulted. Also please check if the driver supports setting RTS/DTR lines or not.
    
    Parameters:
    handle - of the opened port.
    enabled - if true RTS will be asserted and vice-versa.
    
    Returns:
    true on success.
    
    Throws:
    
    SerialComException - if system is unable to complete requested operation.
  - setDTR
```
public boolean setDTR(long handle,
             boolean enabled)
               throws SerialComException
```
    This method assert/de-assert DTR line of serial port. Set "true" for asserting signal, false otherwise. This changes the state of RTS line electrically.
    
    RTS and DTR lines can be asserted or de-asserted even when a serial port is configured as 'flow control none'.
    
    It is possible to establish PPP connections to transmit binary data over a two (or more) wire interface with full handshaking and modem control signaling if the driver is configured for this. Refer application note from FTDI for details : AN232B-09 Using the Modem Emulation Mode in FTDI's VCP Driver.
    
    Parameters:
    handle - of the opened port.
    enabled - if true DTR will be asserted and vice-versa.
    
    Returns:
    true on success.
    
    Throws:
    
    SerialComException - if system is unable to complete requested operation.
  - registerDataListener
```
public boolean registerDataListener(long handle,
                           ISerialComDataListener dataListener)
                             throws SerialComException
```
    This method associate a data looper with the given listener. This looper will keep delivering new data whenever it is made available from native data collection and dispatching subsystem. Note that listener will start receiving new data, even before this method returns.
    
    Application (listener) should implement ISerialComDataListener and override onNewSerialDataAvailable method.
    
    The scm library can manage upto 1024 listeners corresponding to 1024 port handles. Application should not register data listener more than once for the same port otherwise it will lead to inconsistent state.
    
    This method is thread safe.
    
    Parameters:
    handle - of the serial port for which given listener will listen for availability of data bytes.
    dataListener - instance of class which implements ISerialComDataListener interface.
    
    Returns:
    true on success false otherwise.
    
    Throws:
    
    SerialComException - if invalid handle passed, handle is null or data listener already exist for this handle.
    
    IllegalArgumentException - if dataListener is null.
  - unregisterDataListener
```
public boolean unregisterDataListener(long handle,
                             ISerialComDataListener dataListener)
                               throws SerialComException
```
    This method destroys complete java and native looper subsystem associated with this particular data listener. This has no effect on event looper subsystem. This method returns only after native thread has been terminated successfully.
    
    This method is thread safe.
    
    Parameters:
    handle - handle of the serial port for which this data listener was registered.
    dataListener - instance of class which implemented ISerialComDataListener interface.
    
    Returns:
    true on success false otherwise.
    
    Throws:
    
    SerialComException - if null value is passed in dataListener field.
    
    IllegalArgumentException - if dataListener is null.
  - registerLineEventListener
```
public boolean registerLineEventListener(long handle,
                                ISerialComEventListener eventListener)
                                  throws SerialComException
```
    This method associate a event looper with the given listener. This looper will keep delivering new event whenever it is made available from native event collection and dispatching subsystem.
    
    Application (listener) should implement ISerialComEventListener and override onNewSerialEvent method.
    
    By default all four events are dispatched to listener. However, application can mask events through setEventsMask() method. In current implementation, native code sends all the events irrespective of mask and we actually filter them in java layers, to decide whether this should be sent to application or not (as per the mask set by setEventsMask() method).
    
    Before calling this method, make sure that port has been configured for hardware flow control using configureComPortControl method. Application should not register event listener more than once for the same port otherwise it will lead to inconsistent state.
    
    This method is thread safe.
    
    Parameters:
    handle - of the port opened.
    eventListener - instance of class which implements ISerialComEventListener interface.
    
    Returns:
    true on success false otherwise.
    
    Throws:
    
    SerialComException - if invalid handle passed, handle is null or event listener already exist for this handle.
    
    IllegalArgumentException - if eventListener is null.
  - unregisterLineEventListener
```
public boolean unregisterLineEventListener(long handle,
                                  ISerialComEventListener eventListener)
                                    throws SerialComException
```
    This method destroys complete java and native looper subsystem associated with this particular event listener. This has no effect on data looper subsystem.
    
    This method is thread safe.
    
    Parameters:
    handle - handle for which this listener was registered.
    eventListener - instance of class which implemented ISerialComEventListener interface.
    
    Returns:
    true on success false otherwise.
    
    Throws:
    
    SerialComException - if an error occurs.
    
    IllegalArgumentException - if eventListener is null.
  - pauseListeningEvents
```
public boolean pauseListeningEvents(ISerialComEventListener eventListener)
                             throws SerialComException
```
    This pauses delivering events to application. The events kept accumulating in queue.
    
    Parameters:
    eventListener - instance of class which implemented ISerialComEventListener interface.
    
    Returns:
    true on success false otherwise.
    
    Throws:
    
    SerialComException - if null is passed for eventListener field.
    
    IllegalArgumentException - if eventListener is null.
  - resumeListeningEvents
```
public boolean resumeListeningEvents(ISerialComEventListener eventListener)
                              throws SerialComException
```
    Resume delivering events kept in queue to application.
    
    Parameters:
    eventListener - is an instance of class which implements ISerialComEventListener.
    
    Returns:
    true on success false otherwise.
    
    Throws:
    
    SerialComException - if error occurs.
    
    IllegalArgumentException - if eventListener is null.
  - fineTuneReadBehaviour
```
public boolean fineTuneReadBehaviour(long handle,
                            int vmin,
                            int vtime,
                            int rit,
                            int rttm,
                            int rttc)
                              throws SerialComException
```
    This method gives more fine tune control to application for tuning performance and behavior of read operations to leverage OS specific facility for read operation. The read operations can be optimized for receiving for example high volume data speedily or low volume data but received in burst mode.
    
    If more than one client has opened the same port, then all the clients will be affected by new settings.
    
    When this method is called application should make sure that previous read or write operation is not in progress.
    
    Parameters:
    handle - of the opened port.
    vmin - c_cc[VMIN] field of termios structure.
    vtime - c_cc[VTIME] field of termios structure (10th of a second).
    rit - ReadIntervalTimeout field of COMMTIMEOUTS structure.
    rttm - ReadTotalTimeoutMultiplier field of COMMTIMEOUTS structure.
    rttc - ReadTotalTimeoutConstant field of COMMTIMEOUTS structure.
    
    Returns:
    true on success false otherwise.
    
    Throws:
    
    SerialComException - if wrong handle is passed or operation can not be done successfully.
    
    IllegalArgumentException - if invalid combination of arguments is passed.
  - setEventsMask
```
public boolean setEventsMask(ISerialComEventListener eventListener,
                    int newMask)
                      throws SerialComException
```
    Defines for which line events registered event listener will be called.
    
    In future we may shift modifying mask in the native code itself, so as to prevent JNI transitions. This filters what events should be sent to application. Note that, although we sent only those event for which user has set mask, however native code send all the events to java layer as of now.
    
    Parameters:
    eventListener - instance of class which implemented ISerialComEventListener interface.
    
    Returns:
    true on success false otherwise.
    
    Throws:
    
    SerialComException - if invalid listener is passed.
    
    IllegalArgumentException - if eventListener is null.
  - getEventsMask
```
public int getEventsMask(ISerialComEventListener eventListener)
                  throws SerialComException
```
    This method return currently applicable mask for events on serial port.
    
    Parameters:
    eventListener - instance of class which implemented ISerialComEventListener interface.
    
    Returns:
    an integer containing bit fields representing mask.
    
    Throws:
    
    SerialComException - if null or wrong listener is passed.
    
    IllegalArgumentException - if eventListener is null.
  - clearPortIOBuffers
```
public boolean clearPortIOBuffers(long handle,
                         boolean clearRxBuffer,
                         boolean clearTxBuffer)
                           throws SerialComException
```
    Discards data sent to port but not transmitted, or data received but not read. Some device/OS/driver might not have support for this, but most of them may have. If there is some data to be pending for transmission, it will be discarded and therefore no longer sent. If the application wants to make sure that all data has been transmitted before discarding anything, it must first flush data and then call this method.
    
    Parameters:
    handle - of the opened port.
    clearRxBuffer - if true receive buffer will be cleared otherwise will be left untouched.
    clearTxBuffer - if true transmit buffer will be cleared otherwise will be left untouched.
    
    Returns:
    true on success.
    
    Throws:
    
    SerialComException - if invalid handle is passed or operation can not be completed successfully.
    
    IllegalArgumentException - if both purgeTxBuffer and purgeRxBuffer are false.
  - sendBreak
```
public boolean sendBreak(long handle,
                int duration)
                  throws SerialComException
```
    Assert a break condition on the specified port for the duration expressed in milliseconds. If the line is held in the logic low condition (space in UART jargon) for longer than a character time, this is a break condition that can be detected by the UART.
    
    A "break condition" occurs when the receiver input is at the "space" level for longer than some duration of time, typically, for more than a character time. This is not necessarily an error, but appears to the receiver as a character of all zero bits with a framing error. The term "break" derives from current loop Signaling, which was the traditional signaling used for tele-typewriters. The "spacing" condition of a current loop line is indicated by no current flowing, and a very long period of no current flowing is often caused by a break or other fault in the line.
    Recognizing break condition on line is the responsibility of the UART IC, but if for some reason (such as a limited UART that does not implement this functionality) the UART fails to do so, reception of a break will manifest itself as a large number of framing errors.
    All UART devices (or driver) may not support all break timings. For example CP2105 can set break for from 1 to 125 ms or for infinite time. Developers should consult data sheet to know device capabilities.
    
    Parameters:
    handle - of the opened port.
    duration - the time in milliseconds for which break will be active.
    
    Returns:
    true on success.
    
    Throws:
    
    SerialComException - if invalid handle is passed or operation can not be successfully completed.
    
    IllegalArgumentException - if duration is zero or negative.
  - getInterruptCount
```
public int[] getInterruptCount(long handle)
                        throws SerialComException
```
    This method gives the number of interrupts on serial line that have occurred. The interrupt count is in following order in array beginning from index 0 and ending at index 11 : CTS, DSR, RING, CARRIER DETECT, RECEIVER BUFFER, TRANSMIT BUFFER, FRAME ERROR, OVERRUN ERROR, PARITY ERROR, BREAK AND BUFFER OVERRUN.
    
    This is applicable for Linux onle. For other operating systems, this will return 0 for all the indexes.
    
    Parameters:
    handle - of the port opened on which interrupts might have occurred.
    
    Returns:
    array of integers containing values corresponding to each interrupt source.
    
    Throws:
    
    SerialComException - if invalid handle is passed or operation can not be performed successfully.
  - getLinesStatus
```
public int[] getLinesStatus(long handle)
                     throws SerialComException
```
    Gives status of serial port's control lines as supported by underlying operating system. The sequence of status in returned array is :
    
    Linux OS : CTS, DSR, DCD, RI, LOOP, RTS, DTR respectively.
    
    MAC OS X : CTS, DSR, DCD, RI, 0, RTS, DTR respectively.
    
    Windows OS : CTS, DSR, DCD, RI, 0, 0, 0 respectively.
    
    Parameters:
    handle - of the port whose status is to be read.
    
    Returns:
    status of UART port control lines.
    
    Throws:
    
    SerialComException - if invalid handle is passed or operation can not be completed successfully.
  - findDriverServingComPort
```
public String findDriverServingComPort(String comPortName)
                                throws SerialComException
```
    Gives the name of the driver who is driving the given serial port.
    
    Parameters:
    comPortName - name only for windows (for ex; COM52), full path for unix-like os (for ex; /dev/ttyUSB0).
    
    Returns:
    name of driver serving given serial port.
    
    Throws:
    
    SerialComException - if operation can not be completed successfully.
    
    IllegalArgumentException - if argument comPortName is null or is an empty string.
  - findIRQnumberForComPort
```
public String findIRQnumberForComPort(long handle)
                               throws SerialComException
```
    Gives the address and IRQ number associated with the given serial port.
    
    Parameters:
    handle - handle of the opened serial port.
    
    Returns:
    string containing address and irq number in hexadecimal represenation.
    
    Throws:
    
    SerialComException - if operation can not be completed successfully.
  - getByteCountInPortIOBuffer
```
public int[] getByteCountInPortIOBuffer(long handle)
                                 throws SerialComException
```
    Get number of bytes in input and output port buffers used by operating system for instance tty buffers in Unix like systems. Sequence of data in array is : Input buffer byte count, Output buffer byte count.
    
    It should be noted that some chipset specially USB to UART converters might have FIFO buffers in chipset itself. For example FT232R has internal buffers controlled by FIFO CONTROLLERS. For this reason this method should be tested carefully if application is using USB-UART converters. This is driver and OS specific scenario.
    
    Parameters:
    handle - of the opened port for which counts need to be determined.
    
    Returns:
    array containing number of bytes in input and output buffer.
    
    Throws:
    
    SerialComException - if invalid handle is passed or operation can not be completed successfully.
  - registerUSBHotPlugEventListener
```
public int registerUSBHotPlugEventListener(ISerialComUSBHotPlugListener hotPlugListener,
                                  int filterVID,
                                  int filterPID,
                                  String serialNumber)
                                    throws SerialComException
```
    This registers a listener who will be invoked whenever a USB device has been plugged or un-plugged in system. This method can be used to write auto discovery applications for example when a hardware USB device is added to system, application can automatically detect and identify it and launch appropriate service.
    
    This API can be used for detecting both USB-HID and USB-CDC devices. Essentially this API is USB interface agnostic; meaning it would invoke listener for matching USB device irresepective of functionality offered by the USB device.
    
    Application must implement ISerialComUSBHotPlugListener interface and override onUSBHotPlugEvent method. The event value SerialComUSB.DEV_ADDED indicates USB device has been added to the system. The event value SerialComUSB.DEV_REMOVED indicates USB device has been removed from system.
    
    Application can specify the usb device for which callback should be called based on USB VID and USB PID. If the value of filterVID is specified however the value of filterPID is constant SerialComUSB.DEV_ANY, then callback will be called for USB device which matches given VID and its PID can have any value. If the value of filterPID is specified however the value of filterVID is constant SerialComUSB.DEV_ANY, then callback will be called for USB device which matches given PID and its VID can have any value.
    
    If both filterVID and filterPID are set to SerialComUSB.DEV_ANY, then callback will be called for every USB device. Further in listener, USBVID will be 0, if SerialComUSB.DEV_ANY was passed to registerUSBHotPlugEventListener for filterVID argument. USBPID will be 0, if SerialComUSB.DEV_ANY was passed to registerUSBHotPlugEventListener for filterPID and serialNumber will be empty string if null was passed to registerUSBHotPlugEventListener for serialNumber argument.
    
    If the application do not know the USB attributes like the VID/PID/Serial of the device use listUSBdevicesWithInfo() along with hot plug listener. For example; call listUSBdevicesWithInfo(SerialComUSB.V_ALL) and create and arraylist to know what all USB devices are present in system and register this hotplug listener. Now whenever a USB device is attached to system, listener will be called. From with this listener call listUSBdevicesWithInfo(SerialComUSB.V_ALL) and create arraylist again. Compare these two list to find information about newly added device and take next appropriate step
    
    Parameters:
    hotPlugListener - object of class which implements ISerialComUSBHotPlugListener interface.
    filterVID - USB vendor ID to match.
    filterPID - USB product ID to match.
    serialNumber - serial number of USB device (case insensitive, optional, can be null) to match.
    
    Returns:
    opaque handle on success that should be passed to unregisterUSBHotPlugEventListener method for unregistering this listener.
    
    Throws:
    
    SerialComException - if registration fails due to some reason.
    
    IllegalArgumentException - if hotPlugListener is null or if USB VID or USB PID are invalid numbers.
  - unregisterUSBHotPlugEventListener
```
public boolean unregisterUSBHotPlugEventListener(int opaqueHandle)
                                          throws SerialComException
```
    This unregisters listener and terminate native thread used for monitoring specified USB device insertion or removal.
    
    Parameters:
    opaqueHandle - handle returned by registerUSBHotPlugEventListener method for this listener.
    
    Returns:
    true on success.
    
    Throws:
    
    SerialComException - if un-registration fails due to some reason.
    
    IllegalArgumentException - if argument opaqueHandle is negative.
  - getPortName
```
public String getPortName(long handle)
                   throws SerialComException
```
    This method gives the port name with which given handle is associated. If the given handle is unknown to SCM library, null is returned. A serial port is known to SCM if it was opened using SCM library.
    
    Parameters:
    handle - for which the port name is to be found.
    
    Returns:
    port name corresponding to the given handle.
    
    Throws:
    
    SerialComException - if invalid handle is passed.
  - sendFile
```
public boolean sendFile(long handle,
               File fileToSend,
               SerialComManager.FTPPROTO ftpProto,
               SerialComManager.FTPVAR ftpVariant,
               boolean textMode,
               ISerialComXmodemProgress progressListener,
               SerialComXModemAbort transferState)
                 throws SerialComException,
                        SecurityException,
                        FileNotFoundException,
                        SerialComTimeOutException,
                        IOException
```
    Send given file using specified file transfer protocol.
    
    Parameters:
    handle - of the port on which file is to be sent.
    fileToSend - File instance representing file to be sent.
    ftpProto - file transfer protocol to use for communication over serial port.
    ftpVariant - variant of file transfer protocol to use.
    textMode - if true file will be sent as text file (ASCII mode), if false file will be sent as binary file. The text file must contain only valid ASCII characters.
    progressListener - object of class which implements ISerialComXmodemProgress interface and is interested in knowing how many blocks have been sent to file receiver till now. If progressListener is null, update will not be delivered to application.
    transferState - if application wish to abort sending file at instant of time due to any reason, it can call abortTransfer method on this object. If the application does not wishes to abort sending file explicitly transferState can be null.
    
    Returns:
    true on success, false if application instructed to abort.
    
    Throws:
    
    SerialComException - if invalid handle is passed.
    
    SecurityException - If a security manager exists and its SecurityManager.checkRead(java.lang.String) method denies read access to the file.
    
    FileNotFoundException - if the file does not exist, is a directory rather than a regular file, or for some other reason cannot be opened for reading.
    
    SerialComTimeOutException - if timeout occurs as per file transfer protocol.
    
    IOException - if error occurs while reading data from file to be sent.
    
    IllegalArgumentException - if fileToSend or ftpProto or ftpVariant or ftpMode argument is null.
  - receiveFile
```
public boolean receiveFile(long handle,
                  File fileToReceive,
                  SerialComManager.FTPPROTO ftpProto,
                  SerialComManager.FTPVAR ftpVariant,
                  boolean textMode,
                  ISerialComXmodemProgress progressListener,
                  SerialComXModemAbort transferState)
                    throws SerialComException,
                           SecurityException,
                           FileNotFoundException,
                           SerialComTimeOutException,
                           IOException
```
    Receives file using specified file transfer protocol.
    
    Parameters:
    handle - of the port on which file is to be sent.
    fileToReceive - File instance representing file to be sent.
    ftpProto - file transfer protocol to use for communication over serial port.
    ftpVariant - variant of file transfer protocol to use.
    textMode - if true file will be received as text file (ASCII mode), if false file will be received as binary file.
    progressListener - object of class which implements ISerialComXmodemProgress interface and is interested in knowing how many blocks have been received from file sender till now. If progressListener is null, update will not be delivered to application.
    transferState - if application wish to abort receiving file at instant of time due to any reason, it can call abortTransfer method on this object. If the application does not wishes to abort receiving file explicitly transferState can be null.
    
    Returns:
    true on success, false if application instructed to abort.
    
    Throws:
    
    SerialComException - if invalid handle is passed.
    
    SecurityException - If a security manager exists and its SecurityManager.checkRead(java.lang.String) method denies read access to the file.
    
    FileNotFoundException - if the file does not exist, is a directory rather than a regular file, or for some other reason cannot be opened for reading.
    
    SerialComTimeOutException - if timeout occurs as per file transfer protocol.
    
    IOException - if error occurs while reading data from file to be sent.
    
    IllegalArgumentException - if fileToReceive or ftpProto or ftpVariant or ftpMode argument is null.
  - createInputByteStream
```
public SerialComInByteStream createInputByteStream(long handle,
                                          SerialComManager.SMODE streamMode)
                                            throws SerialComException
```
    Prepares context and returns an input streams of bytes for receiving data bytes from the serial port.
    
    A serial port handle can have only one input stream associated with it. Application should close the created stream after it is no longer required.
    
    Parameters:
    handle - handle of the opened port from which to read data bytes.
    
    Returns:
    reference to an object of type SerialComInByteStream.
    
    Throws:
    
    SerialComException - if input stream already exist for this handle or invalid handle is passed.
    
    IllegalArgumentException - if streamMode is null.
  - createOutputByteStream
```
public SerialComOutByteStream createOutputByteStream(long handle,
                                            SerialComManager.SMODE streamMode)
                                              throws SerialComException
```
    Prepares context and returns an output streams of bytes for transferring data bytes out of serial port.
    
    A serial port handle can have only one output stream associated with it. Application should close the created stream after it is no longer required.
    
    Using SerialComOutByteStream for writing data while not using SerialComInByteStream for reading is a valid use case.
    
    Parameters:
    handle - handle of the opened port on which to write data bytes.
    
    Returns:
    reference to an object of type SerialComOutByteStream.
    
    Throws:
    
    SerialComException - if output stream already exist for this handle or invalid handle is passed.
    
    IllegalArgumentException - if streamMode is null.
  - getIOCTLExecutor
```
public SerialComIOCTLExecutor getIOCTLExecutor(long handle)
                                        throws SerialComException
```
    Prepares context for excuting IOCTL operations on the given port.
    
    Parameters:
    handle - handle of the opened port on which to execute ioctl operations.
    
    Returns:
    reference to an object of type SerialComIOCTLExecutor on which various ioctl methods can be invoked.
    
    Throws:
    
    SerialComException - if invalid handle is passed.
  - isUSBDevConnected
```
public boolean isUSBDevConnected(int vendorID,
                        int productID,
                        String serialNumber)
                          throws SerialComException
```
    Checks whether a particular USB device identified by vendor id, product id and serial number is connected to the system or not. The connection infomration is obtained from the operating system.
    
    Parameters:
    vendorID - USB-IF vendor ID of the USB device to match.
    productID - product ID of the USB device to match.
    serialNumber - USB device's serial number (case insensitive, optional). If not required it can be null.
    
    Returns:
    true is device is connected otherwise false.
    
    Throws:
    
    SerialComException - if an I/O error occurs.
    
    IllegalArgumentException - if productID or vendorID is negative or invalid.
  - getVendorLibInstance
```
public SerialComVendorLib getVendorLibInstance(int vendorLibIdentifier,
                                      String libDirectory,
                                      String vlibName)
                                        throws UnsatisfiedLinkError,
                                               SerialComLoadException,
                                               SerialComUnexpectedException,
                                               SecurityException,
                                               FileNotFoundException
```
    Gives an instance of the class which implements API defined by vendor in their propriety library.
    
    For FTDI d2xx, instance of SerialComFTDID2XX class is returned.
    
    Parameters:
    vendorLibIdentifier - one of the constant VLIB_XXXX_XXXX in SerialComVendorLib class.
    libDirectory - absolute directory path where vendor library is placed.
    vlibName - full name of the vendor library (for ex. libftd2xx.so.1.1.12).
    
    Returns:
    an object of SerialComVendorLib class on which vendor specific API calls can be made otherwise null.
    
    Throws:
    
    SerialComUnexpectedException - if a critical java system property is null in system.
    
    SecurityException - if any java system property can not be accessed.
    
    FileNotFoundException - if the vendor library file is not found.
    
    UnsatisfiedLinkError - if loading/linking shared library fails.
    
    SerialComException - if an I/O error occurs.
    
    SerialComLoadException - if the library can not be found, extracted or loaded if the mentioned library is not supported by vendor for operating system and cpu architecture combination.
    
    IllegalArgumentException - if argument vlibName is null or is an empty string.
  - getSerialComUSBInstance
```
public SerialComUSB getSerialComUSBInstance()
                                     throws SerialComException
```
    Get an instance of SerialComUSB class for USB related operations.
    
    Returns:
    instance of SerialComUSB class on which various methods can be invoked.
    
    Throws:
    
    SerialComException - if could not instantiate class due to some reason.
  - getSerialComBluetoothInstance
```
public SerialComBluetooth getSerialComBluetoothInstance(int btStack,
                                               String directoryPath,
                                               String loadedLibName)
                                                 throws SecurityException,
                                                        SerialComUnexpectedException,
                                                        SerialComLoadException,
                                                        UnsatisfiedLinkError,
                                                        SerialComException,
                                                        FileNotFoundException,
                                                        IOException
```
    Initialize and return an instance of SerialComBluetooth for the given bluetooth stack. It prepares context for serial port communication over Bluetooth using 'serial port profile' (SPP) specification of bluetooth standard.
    
    This method will extract native library in directory as specified by directoryPath argument or default directory will be used if directoryPath is null. The native library loaded will be given name as specified by loadedLibName argument or default name will be used if loadedLibName is null.
    
    Parameters:
    btStack - one of the constants BTSTACK_XX_XX defined in SerialComBluetooth class.
    directoryPath - absolute path of directory to be used for extraction.
    loadedLibName - library name without extension (do not append .so, .dll or .dylib etc.).
    
    Returns:
    instance of SerialComBluetooth class on which various methods can be invoked.
    
    Throws:
    
    SerialComException - if could not instantiate class due to some reason.
    
    SecurityException - if java system properties can not be accessed.
    
    SerialComUnexpectedException - if java system property is null.
    
    SerialComLoadException - if any file system related issue occurs.
    
    UnsatisfiedLinkError - if loading/linking shared library fails.
    
    FileNotFoundException - if file "/proc/cpuinfo" can not be found for Linux on ARM platform.
    
    IOException - if file operations on "/proc/cpuinfo" fails for Linux on ARM platform.
    
    SerialComException - if initializing native library fails.
    
    IllegalArgumentException - if btStack is an invalid constant.
  - getSerialComHIDInstance
```
public SerialComHID getSerialComHIDInstance(int type,
                                   String directoryPath,
                                   String loadedLibName)
                                     throws SecurityException,
                                            SerialComUnexpectedException,
                                            SerialComLoadException,
                                            UnsatisfiedLinkError,
                                            SerialComException,
                                            FileNotFoundException,
                                            IOException
```
    Allocate, initialize and return an instance of requested mode for communication with HID device. If the value of variable type is MODE_RAW, instance of class SerialComRawHID is returned. In this mode raw reports are sent and received with device (no report parsing is done). If the type is MODE_PARSED, reports are parsed by operating system as described by report descriptor of the HID device.
    
    HID transport specific APIs defined in SerialComUSBHID and SerialComBluetoothHID can be accessed from with-in SerialComRawHID class.
    
    This method will extract native library in directory as specified by directoryPath argument or default directory will be used if directoryPath is null. The native library loaded will be given name as specified by loadedLibName argument or default name will be used if loadedLibName is null.
    
    Parameters:
    type - one of the constants MODE_XXXX defined in SerialComHID class.
    directoryPath - absolute path of directory to be used for extraction.
    loadedLibName - library name without extension (do not append .so, .dll or .dylib etc.).
    
    Returns:
    instance of SerialComHID class on which various methods can be invoked.
    
    Throws:
    
    SerialComException - if could not instantiate class due to some reason.
    
    SecurityException - if java system properties can not be accessed.
    
    SerialComUnexpectedException - if java system property is null.
    
    SerialComLoadException - if any file system related issue occurs.
    
    UnsatisfiedLinkError - if loading/linking shared library fails.
    
    FileNotFoundException - if file "/proc/cpuinfo" can not be found for Linux on ARM platform.
    
    IOException - if file operations on "/proc/cpuinfo" fails for Linux on ARM platform.
    
    SerialComException - if initializing native library fails.
    
    IllegalArgumentException - if type is an invalid constant.
  - getSerialComPortMapperInstance
```
public SerialComPortMapper getSerialComPortMapperInstance(String directoryPath,
                                                 String loadedLibName)
                                                   throws SerialComException,
                                                          SecurityException,
                                                          SerialComUnexpectedException,
                                                          SerialComLoadException,
                                                          UnsatisfiedLinkError
```
    Allocate, initialize and return an instance of SerialComPortMapper class on whom APIs can be called to map or unmap a serial port alias.
    
    This method will extract native library in directory as specified by directoryPath argument or default directory will be used if directoryPath is null. The native library loaded will be given name as specified by loadedLibName argument or default name will be used if loadedLibName is null.
    
    Parameters:
    directoryPath - absolute path of directory to be used for extraction.
    loadedLibName - library name without extension (do not append .so, .dll or .dylib etc.).
    
    Returns:
    instance of SerialComPortMapper class on which various methods can be invoked.
    
    Throws:
    
    SerialComException - if could not instantiate class due to some reason.
    
    SecurityException - if java system properties can not be accessed.
    
    SerialComUnexpectedException - if java system property is null.
    
    SerialComLoadException - if any file system related issue occurs.
    
    UnsatisfiedLinkError - if loading/linking shared library fails.
    
    FileNotFoundException - if file "/proc/cpuinfo" can not be found for Linux on ARM platform.
    
    IOException - if file operations on "/proc/cpuinfo" fails for Linux on ARM platform.
    
    SerialComException - if an error occurs.
  - getSerialComDBReleaseInstance
```
public SerialComDBRelease getSerialComDBReleaseInstance(String directoryPath,
                                               String loadedLibName)
                                                 throws SerialComException,
                                                        SecurityException,
                                                        SerialComUnexpectedException,
                                                        SerialComLoadException,
                                                        UnsatisfiedLinkError
```
    Allocate, initialize and return an instance of SerialComDBRelease class on whom APIs can be called to release COM ports in use. This methed is applicable for Windows operating system only.
    
    The Windows operating system maintains a database of all COM ports. This database is typically supports com port numbers from 1(COM1) to 256(COM256). This database can get exhausted for example if more than 256 USB-UART devices are connected one after the other in system. This generally happens in factory testing environment. Using the APIs in SerialComDBRelease class, test application can manage the port assignment and its release programatically making production testing faster and less cumbersome.
    
    This method will extract native library in directory as specified by directoryPath argument or default directory will be used if directoryPath is null. The native library loaded will be given name as specified by loadedLibName argument or default name will be used if loadedLibName is null.
    
    Parameters:
    directoryPath - absolute path of directory to be used for extraction.
    loadedLibName - library name without extension (do not append .so, .dll or .dylib etc.).
    
    Returns:
    instance of SerialComDBRelease on which various methods can be invoked.
    
    Throws:
    
    SerialComException - if could not instantiate class due to some reason.
    
    SecurityException - if java system properties can not be accessed.
    
    SerialComUnexpectedException - if java system property is null.
    
    SerialComLoadException - if any file system related issue occurs.
    
    UnsatisfiedLinkError - if loading/linking shared library fails.
    
    FileNotFoundException - if file "/proc/cpuinfo" can not be found for Linux on ARM platform.
    
    IOException - if file operations on "/proc/cpuinfo" fails for Linux on ARM platform.
    
    SerialComException - if initializing native library fails.
  - getSerialComKeyStrokeAppInstance
```
public SerialComToKeyStrokeToApp getSerialComKeyStrokeAppInstance(long handle)
                                                           throws AWTException
```
    Throws:
    
    AWTException

Class SerialComManager

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

JAVA_LIB_VERSION

OS_UNKNOWN

OS_LINUX

OS_WINDOWS

OS_SOLARIS

OS_MAC_OS_X

OS_FREEBSD

OS_NETBSD

OS_OPENBSD

OS_IBM_AIX

OS_HP_UX

OS_ANDROID

ARCH_UNKNOWN

ARCH_X86

ARCH_AMD64

ARCH_IA64

ARCH_IA64_32

ARCH_PPC32

ARCH_PPC64

ARCH_PPC64LE

ARCH_SPARC32

ARCH_SPARC64

ARCH_PA_RISC32

ARCH_PA_RISC64

ARCH_S390

ARCH_S390X

ARCH_ARMV5

ARCH_ARMV6

ARCH_ARMV7

ABI_ARMHF

ABI_ARMEL

DEFAULT_READBYTECOUNT

CTS

DSR

DCD

RI

LOOP

RTS

DTR

EXP_UNBLOCKIO

Constructor Detail

SerialComManager

SerialComManager

Method Detail

getLibraryVersions

getOSType

getCPUArchitecture

listAvailableComPorts

listUSBdevicesWithInfo

findComPortFromUSBAttributes

listBTSPPDevNodesWithInfo

openComPort

closeComPort

writeBytes

writeBytes

writeSingleByte

writeString

writeString

writeSingleInt

writeIntArray

writeBytesDirect

writeBytesBlocking

readBytesDirect

createBlockingIOContext

unblockBlockingIOOperation

destroyBlockingIOContext

readBytesBlocking

readBytes

readBytes

readString

readString

readSingleByte

readBytes