Example usage for java.nio ByteBuffer getShort

List of usage examples for java.nio ByteBuffer getShort

Introduction

In this page you can find the example usage for java.nio ByteBuffer getShort.

Prototype

public abstract short getShort(int index);

Source Link

Document

Returns the short at the specified index.

Usage

From source file:com.healthmarketscience.jackcess.impl.TableImpl.java

/**
 * Reads the column data from the given row buffer.  Leaves limit unchanged.
 * Caches the returned value in the rowState.
 *///from   w  ww.  ja  v a2  s  .co m
private static Object getRowColumn(JetFormat format, ByteBuffer rowBuffer, ColumnImpl column, RowState rowState,
        Map<ColumnImpl, byte[]> rawVarValues) throws IOException {
    byte[] columnData = null;
    try {

        NullMask nullMask = rowState.getNullMask(rowBuffer);
        boolean isNull = nullMask.isNull(column);
        if (column.storeInNullMask()) {
            // Boolean values are stored in the null mask.  see note about
            // caching below
            return rowState.setRowCacheValue(column.getColumnIndex(), column.readFromNullMask(isNull));
        } else if (isNull) {
            // well, that's easy! (no need to update cache w/ null)
            return null;
        }

        Object cachedValue = rowState.getRowCacheValue(column.getColumnIndex());
        if (cachedValue != null) {
            // we already have it, use it
            return cachedValue;
        }

        // reset position to row start
        rowBuffer.reset();

        // locate the column data bytes
        int rowStart = rowBuffer.position();
        int colDataPos = 0;
        int colDataLen = 0;
        if (!column.isVariableLength()) {

            // read fixed length value (non-boolean at this point)
            int dataStart = rowStart + format.OFFSET_COLUMN_FIXED_DATA_ROW_OFFSET;
            colDataPos = dataStart + column.getFixedDataOffset();
            colDataLen = column.getType().getFixedSize(column.getLength());

        } else {
            int varDataStart;
            int varDataEnd;

            if (format.SIZE_ROW_VAR_COL_OFFSET == 2) {

                // read simple var length value
                int varColumnOffsetPos = (rowBuffer.limit() - nullMask.byteSize() - 4)
                        - (column.getVarLenTableIndex() * 2);

                varDataStart = rowBuffer.getShort(varColumnOffsetPos);
                varDataEnd = rowBuffer.getShort(varColumnOffsetPos - 2);

            } else {

                // read jump-table based var length values
                short[] varColumnOffsets = readJumpTableVarColOffsets(rowState, rowBuffer, rowStart, nullMask);

                varDataStart = varColumnOffsets[column.getVarLenTableIndex()];
                varDataEnd = varColumnOffsets[column.getVarLenTableIndex() + 1];
            }

            colDataPos = rowStart + varDataStart;
            colDataLen = varDataEnd - varDataStart;
        }

        // grab the column data
        rowBuffer.position(colDataPos);
        columnData = ByteUtil.getBytes(rowBuffer, colDataLen);

        if ((rawVarValues != null) && column.isVariableLength()) {
            // caller wants raw value as well
            rawVarValues.put(column, columnData);
        }

        // parse the column data.  we cache the row values in order to be able
        // to update the index on row deletion.  note, most of the returned
        // values are immutable, except for binary data (returned as byte[]),
        // but binary data shouldn't be indexed anyway.
        return rowState.setRowCacheValue(column.getColumnIndex(), column.read(columnData));

    } catch (Exception e) {

        // cache "raw" row value.  see note about caching above
        rowState.setRowCacheValue(column.getColumnIndex(), ColumnImpl.rawDataWrapper(columnData));

        return rowState.handleRowError(column, columnData, e);
    }
}

From source file:com.healthmarketscience.jackcess.Table.java

/**
 * Update the row on which the given rowState is currently positioned.
 * <p>/*from  ww  w.j av a2s  .  c o m*/
 * Note, this method is not generally meant to be used directly.  You should
 * use the {@link #updateCurrentRow} method or use the Cursor class, which
 * allows for more complex table interactions, e.g.
 * {@link Cursor#setCurrentRowValue} and {@link Cursor#updateCurrentRow}.
 * @usage _advanced_method_
 */
public void updateRow(RowState rowState, RowId rowId, Object... row) throws IOException {
    requireValidRowId(rowId);

    // ensure that the relevant row state is up-to-date
    ByteBuffer rowBuffer = positionAtRowData(rowState, rowId);
    int oldRowSize = rowBuffer.remaining();

    requireNonDeletedRow(rowState, rowId);

    // we need to make sure the row is the right length & type (fill with
    // null if too short).
    if ((row.length < _columns.size()) || (row.getClass() != Object[].class)) {
        row = dupeRow(row, _columns.size());
    }

    // fill in any auto-numbers (we don't allow autonumber values to be
    // modified)
    handleAutoNumbersForUpdate(row, rowBuffer, rowState);

    // hang on to the raw values of var length columns we are "keeping".  this
    // will allow us to re-use pre-written var length data, which can save
    // space for things like long value columns.
    Map<Column, byte[]> rawVarValues = (!_varColumns.isEmpty() ? new HashMap<Column, byte[]>() : null);

    // fill in any "keep value" fields
    for (Column column : _columns) {
        if (column.getRowValue(row) == Column.KEEP_VALUE) {
            column.setRowValue(row, getRowColumn(getFormat(), rowBuffer, column, rowState, rawVarValues));
        }
    }

    // generate new row bytes
    ByteBuffer newRowData = createRow(row, _singleRowBufferH.getPageBuffer(getPageChannel()), oldRowSize,
            rawVarValues);

    if (newRowData.limit() > getFormat().MAX_ROW_SIZE) {
        throw new IOException("Row size " + newRowData.limit() + " is too large");
    }

    if (!_indexDatas.isEmpty()) {
        Object[] oldRowValues = rowState.getRowValues();

        // delete old values from indexes
        for (IndexData indexData : _indexDatas) {
            indexData.deleteRow(oldRowValues, rowId);
        }
    }

    // see if we can squeeze the new row data into the existing row
    rowBuffer.reset();
    int rowSize = newRowData.remaining();

    ByteBuffer dataPage = null;
    int pageNumber = PageChannel.INVALID_PAGE_NUMBER;

    if (oldRowSize >= rowSize) {

        // awesome, slap it in!
        rowBuffer.put(newRowData);

        // grab the page we just updated
        dataPage = rowState.getFinalPage();
        pageNumber = rowState.getFinalRowId().getPageNumber();

    } else {

        // bummer, need to find a new page for the data
        dataPage = findFreeRowSpace(rowSize, null, PageChannel.INVALID_PAGE_NUMBER);
        pageNumber = _addRowBufferH.getPageNumber();

        RowId headerRowId = rowState.getHeaderRowId();
        ByteBuffer headerPage = rowState.getHeaderPage();
        if (pageNumber == headerRowId.getPageNumber()) {
            // new row is on the same page as header row, share page
            dataPage = headerPage;
        }

        // write out the new row data (set the deleted flag on the new data row
        // so that it is ignored during normal table traversal)
        int rowNum = addDataPageRow(dataPage, rowSize, getFormat(), DELETED_ROW_MASK);
        dataPage.put(newRowData);

        // write the overflow info into the header row and clear out the
        // remaining header data
        rowBuffer = PageChannel.narrowBuffer(headerPage,
                findRowStart(headerPage, headerRowId.getRowNumber(), getFormat()),
                findRowEnd(headerPage, headerRowId.getRowNumber(), getFormat()));
        rowBuffer.put((byte) rowNum);
        ByteUtil.put3ByteInt(rowBuffer, pageNumber);
        ByteUtil.clearRemaining(rowBuffer);

        // set the overflow flag on the header row
        int headerRowIndex = getRowStartOffset(headerRowId.getRowNumber(), getFormat());
        headerPage.putShort(headerRowIndex, (short) (headerPage.getShort(headerRowIndex) | OVERFLOW_ROW_MASK));
        if (pageNumber != headerRowId.getPageNumber()) {
            writeDataPage(headerPage, headerRowId.getPageNumber());
        }
    }

    // update the indexes
    for (IndexData indexData : _indexDatas) {
        indexData.addRow(row, rowId);
    }

    writeDataPage(dataPage, pageNumber);

    updateTableDefinition(0);
}

From source file:com.healthmarketscience.jackcess.impl.TableImpl.java

/**
 * Update the row for the given rowId.//from ww w.j a v  a  2 s. co  m
 * @usage _advanced_method_
 */
public Object[] updateRow(RowState rowState, RowIdImpl rowId, Object... row) throws IOException {
    requireValidRowId(rowId);

    getPageChannel().startWrite();
    try {

        // ensure that the relevant row state is up-to-date
        ByteBuffer rowBuffer = positionAtRowData(rowState, rowId);
        int oldRowSize = rowBuffer.remaining();

        requireNonDeletedRow(rowState, rowId);

        // we need to make sure the row is the right length & type (fill with
        // null if too short).
        if ((row.length < _columns.size()) || (row.getClass() != Object[].class)) {
            row = dupeRow(row, _columns.size());
        }

        // hang on to the raw values of var length columns we are "keeping".  this
        // will allow us to re-use pre-written var length data, which can save
        // space for things like long value columns.
        Map<ColumnImpl, byte[]> keepRawVarValues = (!_varColumns.isEmpty() ? new HashMap<ColumnImpl, byte[]>()
                : null);

        // handle various value massaging activities
        for (ColumnImpl column : _columns) {

            Object rowValue = null;
            if (column.isAutoNumber()) {

                // fill in any auto-numbers (we don't allow autonumber values to be
                // modified)
                rowValue = getRowColumn(getFormat(), rowBuffer, column, rowState, null);

            } else {

                rowValue = column.getRowValue(row);
                if (rowValue == Column.KEEP_VALUE) {

                    // fill in any "keep value" fields (restore old value)
                    rowValue = getRowColumn(getFormat(), rowBuffer, column, rowState, keepRawVarValues);

                } else {

                    // set oldValue to something that could not possibly be a real value
                    Object oldValue = Column.KEEP_VALUE;
                    if (_indexColumns.contains(column)) {
                        // read (old) row value to help update indexes
                        oldValue = getRowColumn(getFormat(), rowBuffer, column, rowState, null);
                    } else {
                        oldValue = rowState.getRowCacheValue(column.getColumnIndex());
                    }

                    // if the old value was passed back in, we don't need to validate
                    if (oldValue != rowValue) {
                        // pass input value through column validator
                        rowValue = column.validate(rowValue);
                    }
                }
            }

            column.setRowValue(row, rowValue);
        }

        // generate new row bytes
        ByteBuffer newRowData = createRow(row, _writeRowBufferH.getPageBuffer(getPageChannel()), oldRowSize,
                keepRawVarValues);

        if (newRowData.limit() > getFormat().MAX_ROW_SIZE) {
            throw new IOException("Row size " + newRowData.limit() + " is too large");
        }

        if (!_indexDatas.isEmpty()) {

            IndexData.PendingChange idxChange = null;
            try {

                Object[] oldRowValues = rowState.getRowCacheValues();

                // check foreign keys before actually updating
                _fkEnforcer.updateRow(oldRowValues, row);

                // prepare index updates
                for (IndexData indexData : _indexDatas) {
                    idxChange = indexData.prepareUpdateRow(oldRowValues, rowId, row, idxChange);
                }

                // complete index updates
                IndexData.commitAll(idxChange);

            } catch (ConstraintViolationException ce) {
                IndexData.rollbackAll(idxChange);
                throw ce;
            }
        }

        // see if we can squeeze the new row data into the existing row
        rowBuffer.reset();
        int rowSize = newRowData.remaining();

        ByteBuffer dataPage = null;
        int pageNumber = PageChannel.INVALID_PAGE_NUMBER;

        if (oldRowSize >= rowSize) {

            // awesome, slap it in!
            rowBuffer.put(newRowData);

            // grab the page we just updated
            dataPage = rowState.getFinalPage();
            pageNumber = rowState.getFinalRowId().getPageNumber();

        } else {

            // bummer, need to find a new page for the data
            dataPage = findFreeRowSpace(rowSize, null, PageChannel.INVALID_PAGE_NUMBER);
            pageNumber = _addRowBufferH.getPageNumber();

            RowIdImpl headerRowId = rowState.getHeaderRowId();
            ByteBuffer headerPage = rowState.getHeaderPage();
            if (pageNumber == headerRowId.getPageNumber()) {
                // new row is on the same page as header row, share page
                dataPage = headerPage;
            }

            // write out the new row data (set the deleted flag on the new data row
            // so that it is ignored during normal table traversal)
            int rowNum = addDataPageRow(dataPage, rowSize, getFormat(), DELETED_ROW_MASK);
            dataPage.put(newRowData);

            // write the overflow info into the header row and clear out the
            // remaining header data
            rowBuffer = PageChannel.narrowBuffer(headerPage,
                    findRowStart(headerPage, headerRowId.getRowNumber(), getFormat()),
                    findRowEnd(headerPage, headerRowId.getRowNumber(), getFormat()));
            rowBuffer.put((byte) rowNum);
            ByteUtil.put3ByteInt(rowBuffer, pageNumber);
            ByteUtil.clearRemaining(rowBuffer);

            // set the overflow flag on the header row
            int headerRowIndex = getRowStartOffset(headerRowId.getRowNumber(), getFormat());
            headerPage.putShort(headerRowIndex,
                    (short) (headerPage.getShort(headerRowIndex) | OVERFLOW_ROW_MASK));
            if (pageNumber != headerRowId.getPageNumber()) {
                writeDataPage(headerPage, headerRowId.getPageNumber());
            }
        }

        writeDataPage(dataPage, pageNumber);

        updateTableDefinition(0);

    } finally {
        getPageChannel().finishWrite();
    }

    return row;
}

From source file:com.healthmarketscience.jackcess.impl.TableImpl.java

/**
 * Delete the row for the given rowId.//from   w  w w.  j a v a 2s  .  c  om
 * @usage _advanced_method_
 */
public void deleteRow(RowState rowState, RowIdImpl rowId) throws IOException {
    requireValidRowId(rowId);

    getPageChannel().startWrite();
    try {

        // ensure that the relevant row state is up-to-date
        ByteBuffer rowBuffer = positionAtRowHeader(rowState, rowId);

        if (rowState.isDeleted()) {
            // don't care about duplicate deletion
            return;
        }
        requireNonDeletedRow(rowState, rowId);

        // delete flag always gets set in the "header" row (even if data is on
        // overflow row)
        int pageNumber = rowState.getHeaderRowId().getPageNumber();
        int rowNumber = rowState.getHeaderRowId().getRowNumber();

        // attempt to fill in index column values
        Object[] rowValues = null;
        if (!_indexDatas.isEmpty()) {

            // move to row data to get index values
            rowBuffer = positionAtRowData(rowState, rowId);

            for (ColumnImpl idxCol : _indexColumns) {
                getRowColumn(getFormat(), rowBuffer, idxCol, rowState, null);
            }

            // use any read rowValues to help update the indexes
            rowValues = rowState.getRowCacheValues();

            // check foreign keys before proceeding w/ deletion
            _fkEnforcer.deleteRow(rowValues);

            // move back to the header
            rowBuffer = positionAtRowHeader(rowState, rowId);
        }

        // finally, pull the trigger
        int rowIndex = getRowStartOffset(rowNumber, getFormat());
        rowBuffer.putShort(rowIndex,
                (short) (rowBuffer.getShort(rowIndex) | DELETED_ROW_MASK | OVERFLOW_ROW_MASK));
        writeDataPage(rowBuffer, pageNumber);

        // update the indexes
        for (IndexData indexData : _indexDatas) {
            indexData.deleteRow(rowValues, rowId);
        }

        // make sure table def gets updated
        updateTableDefinition(-1);

    } finally {
        getPageChannel().finishWrite();
    }
}

From source file:org.energy_home.jemma.javagal.layers.data.implementations.IDataLayerImplementation.DataFreescale.java

public void processMessages() throws Exception {
    // Look on received messages
    int _size = 0;
    synchronized (this) {
        _size = messages.size();//ww  w.j  a va 2  s  .c o  m
    }

    while (_size > 0) {
        short[] message = null;
        synchronized (this) {
            message = messages.remove(0);
        }

        ByteBuffer bb = ByteBuffer.allocate(2);
        bb.order(ByteOrder.BIG_ENDIAN);
        bb.put((byte) message[0]);
        bb.put((byte) message[1]);
        short _command = bb.getShort(0);

        /* APSDE-DATA.Indication */
        if (_command == FreescaleConstants.APSDEDataIndication) {
            final APSMessageEvent messageEvent = new APSMessageEvent();
            short destAddressMode = message[3];
            messageEvent.setDestinationAddressMode((long) destAddressMode);
            BigInteger _ieee = null;
            Address address = new Address();
            switch (destAddressMode) {
            case 0x00:
                // Reserved (No source address supplied)
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info("Message Discarded: found reserved 0x00 as Destination Address Mode ");
                } // Error found, we don't proceed and discard the
                  // message
                return;
            case 0x01:
                // Value16bitgroupfordstAddr (DstEndpoint not
                // present)
                // No destination end point (so FF broadcast),
                // present
                // short
                // address on 2 bytes
                address.setNetworkAddress(
                        DataManipulation.toIntFromShort((byte) message[5], (byte) message[4]));

                _ieee = gal.getIeeeAddress_FromNetworkCache(address.getNetworkAddress());
                if (_ieee != null)
                    address.setIeeeAddress(_ieee);

                messageEvent.setDestinationAddress(address);
                messageEvent.setDestinationEndpoint((short) 0xff);

                break;
            case 0x02:
                // Value16bitAddrandDstEndpoint (16 bit address
                // supplied)
                address.setNetworkAddress(
                        DataManipulation.toIntFromShort((byte) message[5], (byte) message[4]));
                _ieee = gal.getIeeeAddress_FromNetworkCache(address.getNetworkAddress());
                if (_ieee != null)
                    address.setIeeeAddress(_ieee);

                messageEvent.setDestinationAddress(address);
                messageEvent.setDestinationEndpoint(message[6]);
                break;
            default:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.error("Message Discarded: not valid Destination Address Mode");
                }
                // Error found, we don't proceed and discard the
                // message
                return;
            }
            messageEvent.setSourceAddressMode((long) message[7]);
            address = new Address();
            address.setNetworkAddress(DataManipulation.toIntFromShort((byte) message[9], (byte) message[8]));
            _ieee = gal.getIeeeAddress_FromNetworkCache(address.getNetworkAddress());
            if (_ieee != null)
                address.setIeeeAddress(_ieee);
            messageEvent.setSourceAddress(address);
            messageEvent.setSourceEndpoint(message[10]);
            messageEvent.setProfileID(DataManipulation.toIntFromShort((byte) message[12], (byte) message[11]));
            messageEvent.setClusterID(DataManipulation.toIntFromShort((byte) message[14], (byte) message[13]));

            if (gal.getGatewayStatus() == GatewayStatus.GW_RUNNING && gal.get_GalNode() != null) {
                /* Update The Node Data */

                int _indexOnCache = -1;
                _indexOnCache = gal.existIntoNetworkCache(address.getNetworkAddress());
                if (_indexOnCache != -1) {
                    /* The node is already into the DB */
                    if (gal.getPropertiesManager().getKeepAliveThreshold() > 0) {
                        if (!gal.getNetworkcache().get(_indexOnCache).isSleepy()) {
                            gal.getNetworkcache().get(_indexOnCache).reset_numberOfAttempt();
                            gal.getNetworkcache().get(_indexOnCache)
                                    .setTimerFreshness(gal.getPropertiesManager().getKeepAliveThreshold());
                            if (gal.getPropertiesManager().getDebugEnabled()) {
                                //System.out.println("\n\rPostponing  timer Freshness by Aps.Indication for node:" + gal.getNetworkcache().get(_indexOnCache).get_node().getAddress().getNetworkAddress() + "\n\r");
                                logger.info("Postponing  timer Freshness by Aps.Indication for node:"
                                        + gal.getNetworkcache().get(_indexOnCache).get_node().getAddress()
                                                .getNetworkAddress());
                            }
                        }

                    }
                } else {
                    // 0x8034 is a LeaveAnnouncement, 0x0013 is a
                    // DeviceAnnouncement, 0x8001 is a IEEE_Addr_Rsp
                    if ((gal.getPropertiesManager().getAutoDiscoveryUnknownNodes() > 0)
                            && (!(messageEvent.getProfileID() == 0x0000
                                    && (messageEvent.getClusterID() == 0x0013
                                            || messageEvent.getClusterID() == 0x8034
                                            || messageEvent.getClusterID() == 0x8001)))) {

                        if (address.getNetworkAddress() != gal.get_GalNode().get_node().getAddress()
                                .getNetworkAddress()) {
                            Runnable thr = new MyThread(address) {
                                @Override
                                public void run() {
                                    Address _address = (Address) this.getParameter();
                                    int _indexOnCache = -1;
                                    _indexOnCache = gal.existIntoNetworkCache(_address.getNetworkAddress());
                                    if (_indexOnCache == -1) {

                                        if (gal.getPropertiesManager().getDebugEnabled()) {
                                            //System.out.println("\n\rAutoDiscoveryUnknownNodes procedure of Node:" + messageEvent.getSourceAddress().getNetworkAddress() + "\n\r");

                                            logger.info("AutoDiscoveryUnknownNodes procedure of Node:"
                                                    + messageEvent.getSourceAddress().getNetworkAddress());
                                        }
                                        try {

                                            // Insert the node into cache,
                                            // but with the
                                            // discovery_completed flag a
                                            // false
                                            BigInteger ieee = null;
                                            WrapperWSNNode o = new WrapperWSNNode(gal);
                                            WSNNode _newNode = new WSNNode();
                                            o.set_discoveryCompleted(false);
                                            _newNode.setAddress(_address);
                                            o.set_node(_newNode);
                                            gal.getNetworkcache().add(o);

                                            Thread.sleep(500);
                                            /*
                                             * Reading the IEEEAddress of
                                             * the new node
                                             */

                                            if (gal.getPropertiesManager().getDebugEnabled())
                                                logger.info(
                                                        "Sending IeeeReq to:" + _address.getNetworkAddress());
                                            System.out.println(
                                                    "Sending IeeeReq to:" + _address.getNetworkAddress());
                                            ieee = readExtAddress(INTERNAL_TIMEOUT,
                                                    _address.getNetworkAddress().shortValue());
                                            _address.setIeeeAddress(ieee);
                                            if (gal.getPropertiesManager().getDebugEnabled()) {
                                                logger.info("Readed Ieee of the new node:"
                                                        + _address.getNetworkAddress() + " Ieee: "
                                                        + ieee.toString());
                                                System.out.println("Readed Ieee of the new node:"
                                                        + _address.getNetworkAddress() + " Ieee: "
                                                        + ieee.toString());

                                            }
                                            if (gal.getPropertiesManager().getDebugEnabled())
                                                logger.info("Sending NodeDescriptorReq to:"
                                                        + _address.getNetworkAddress());
                                            NodeDescriptor _ndesc = getNodeDescriptorSync(INTERNAL_TIMEOUT,
                                                    _address);
                                            _newNode.setCapabilityInformation(_ndesc.getMACCapabilityFlag());

                                            if (gal.getPropertiesManager().getDebugEnabled()) {
                                                logger.info("Readed NodeDescriptor of the new node:"
                                                        + _address.getNetworkAddress());
                                                System.out.println("Readed NodeDescriptor of the new node:"
                                                        + _address.getNetworkAddress());

                                            }

                                            o.reset_numberOfAttempt();
                                            o.set_discoveryCompleted(true);
                                            if (!o.isSleepy()) {

                                                if (gal.getPropertiesManager().getKeepAliveThreshold() > 0) {
                                                    o.setTimerFreshness(
                                                            gal.getPropertiesManager().getKeepAliveThreshold());
                                                }
                                                if (gal.getPropertiesManager().getForcePingTimeout() > 0) {
                                                    o.setTimerForcePing(
                                                            gal.getPropertiesManager().getForcePingTimeout());
                                                }
                                            }

                                            _indexOnCache = gal.existIntoNetworkCache(
                                                    _newNode.getAddress().getNetworkAddress());
                                            if (_indexOnCache > -1) {
                                                gal.getNetworkcache().remove(_indexOnCache);

                                            }

                                            // Updating the node
                                            // informations
                                            gal.getNetworkcache().add(o);
                                            o.set_discoveryCompleted(true);
                                            Status _st = new Status();
                                            _st.setCode((short) GatewayConstants.SUCCESS);
                                            gal.get_gatewayEventManager().nodeDiscovered(_st, _newNode);

                                        } catch (GatewayException e) {
                                            logger.error("Error on getAutoDiscoveryUnknownNodes for node:"
                                                    + _address.getNetworkAddress() + " Error:"
                                                    + e.getMessage());

                                            System.out.println("Error on getAutoDiscoveryUnknownNodes for node:"
                                                    + _address.getNetworkAddress() + " Error:"
                                                    + e.getMessage());

                                            _indexOnCache = gal
                                                    .existIntoNetworkCache(_address.getNetworkAddress());
                                            if (_indexOnCache > -1) {
                                                gal.getNetworkcache().get(_indexOnCache).abortTimers();
                                                gal.getNetworkcache().remove(_indexOnCache);
                                            }

                                        } catch (Exception e) {
                                            logger.error("Error on getAutoDiscoveryUnknownNodes for node:"
                                                    + _address.getNetworkAddress() + " Error:"
                                                    + e.getMessage());
                                            System.out.println("Error on getAutoDiscoveryUnknownNodes for node:"
                                                    + _address.getNetworkAddress() + " Error:"
                                                    + e.getMessage());
                                            _indexOnCache = gal
                                                    .existIntoNetworkCache(_address.getNetworkAddress());
                                            if (_indexOnCache > -1) {
                                                gal.getNetworkcache().get(_indexOnCache).abortTimers();
                                                gal.getNetworkcache().remove(_indexOnCache);

                                            }

                                        }
                                    }
                                }
                            };

                            Thread _thr0 = new Thread(thr);
                            _thr0.setName("Thread getAutoDiscoveryUnknownNodes:" + address.getNetworkAddress());
                            _thr0.start();
                        }
                    }
                }

            }
            int lastAsdu = 16 + message[15] - 1;

            messageEvent.setData(DataManipulation.subByteArray(message, 16, lastAsdu));
            messageEvent.setAPSStatus(message[lastAsdu + 1]);
            // ASK Jump WasBroadcast
            // Security Status
            switch (message[lastAsdu + 3]) {
            case 0x00:
                messageEvent.setSecurityStatus(SecurityStatus.UNSECURED);
                break;
            case 0x01:
                messageEvent.setSecurityStatus(SecurityStatus.SECURED_NWK_KEY);
                break;
            case 0x02:
                messageEvent.setSecurityStatus(SecurityStatus.SECURED_LINK_KEY);
                break;
            // ASK 0x03 not present on telecomitalia object
            default:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info("Message Discarded: not valid Security Status");
                }
                // Error found, we don't proceed and discard the
                // message
                return;
            }
            messageEvent.setLinkQuality(message[lastAsdu + 4]);
            messageEvent.setRxTime((long) DataManipulation.toIntFromShort((byte) message[(lastAsdu + 8)],
                    (byte) message[(lastAsdu + 5)]));
            // ASK: jumped iMsgType, pNext, iDataSize, pData,
            // iBufferNumber
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted APSDE-DATA.Indication", message);
            if ((messageEvent.getDestinationAddressMode() == GatewayConstants.ADDRESS_MODE_SHORT)
                    && (messageEvent.getDestinationAddress().getIeeeAddress() == null))
                messageEvent.getDestinationAddress().setIeeeAddress(gal.getIeeeAddress_FromNetworkCache(
                        messageEvent.getDestinationAddress().getNetworkAddress()));

            if ((messageEvent.getDestinationAddressMode() == GatewayConstants.EXTENDED_ADDRESS_MODE)
                    && (messageEvent.getDestinationAddress().getNetworkAddress() == null))
                messageEvent.getDestinationAddress().setNetworkAddress(gal.getShortAddress_FromNetworkCache(
                        messageEvent.getDestinationAddress().getIeeeAddress()));

            if ((messageEvent.getSourceAddressMode() == GatewayConstants.ADDRESS_MODE_SHORT)
                    && (messageEvent.getDestinationAddress().getIeeeAddress() == null))
                messageEvent.getSourceAddress().setIeeeAddress(gal
                        .getIeeeAddress_FromNetworkCache(messageEvent.getSourceAddress().getNetworkAddress()));

            if ((messageEvent.getSourceAddressMode() == GatewayConstants.EXTENDED_ADDRESS_MODE)
                    && (messageEvent.getDestinationAddress().getNetworkAddress() == null))
                messageEvent.getSourceAddress().setNetworkAddress(
                        gal.getShortAddress_FromNetworkCache(messageEvent.getSourceAddress().getIeeeAddress()));

            if (messageEvent.getProfileID().equals(0)) {/*
                                                        * ZDO Command
                                                        */
                if (messageEvent.getClusterID() == 0x8031) {
                    String __key = "";
                    __key = String.format("%04X", messageEvent.getSourceAddress().getNetworkAddress());
                    synchronized (listLocker) {
                        for (ParserLocker pl : listLocker) {
                            if ((pl.getType() == TypeMessage.LQI_REQ) && __key.equalsIgnoreCase(pl.get_Key())) {
                                synchronized (pl) {
                                    pl.getStatus().setCode((short) messageEvent.getAPSStatus());
                                    Mgmt_LQI_rsp _res = new Mgmt_LQI_rsp(messageEvent.getData());
                                    pl.set_objectOfResponse(_res);
                                    pl.notify();
                                }
                                break;
                            }
                        }
                    }
                }
                // profileid == 0
                gal.getZdoManager().ZDOMessageIndication(messageEvent);
            } else {
                // profileid > 0
                ZCLMessage _zm = new ZCLMessage();
                _zm.setAPSStatus(messageEvent.getAPSStatus());
                _zm.setClusterID(messageEvent.getClusterID());
                _zm.setDestinationEndpoint(messageEvent.getDestinationEndpoint());
                _zm.setProfileID(messageEvent.getProfileID());
                _zm.setRxTime(messageEvent.getRxTime());
                _zm.setSourceAddress(messageEvent.getSourceAddress());
                _zm.setSourceAddressMode(messageEvent.getSourceAddressMode());
                _zm.setSourceEndpoint(messageEvent.getSourceEndpoint());

                byte[] data = messageEvent.getData();
                // ZCL Header
                // Frame control 8bit
                // Manufacturer code 0/16bits
                // Transaction sequence number 8bit
                // Command identifier 8 bit
                ByteArrayObject _header = new ByteArrayObject();
                ByteArrayObject _payload = new ByteArrayObject();
                if ((data[0] & 0x04) == 1)/* Check manufacturer code */
                {
                    _header.addByte(data[0]);// Frame control
                    _header.addByte(data[1]);// Manufacturer Code(1/2)
                    _header.addByte(data[2]);// Manufacturer Code(2/2)
                    _header.addByte(data[3]);// Transaction sequence number
                    _header.addByte(data[4]);// Command Identifier
                    for (int i = 5; i < data.length; i++)
                        _payload.addByte(data[i]);
                } else {
                    _header.addByte(data[0]);// Frame control
                    _header.addByte(data[1]);// Transaction sequence number
                    _header.addByte(data[2]);// Command Identifier
                    for (int i = 3; i < data.length; i++)
                        _payload.addByte(data[i]);
                }

                _zm.setZCLHeader(_header.getRealByteArray());
                _zm.setZCLPayload(_payload.getRealByteArray());
                gal.get_gatewayEventManager().notifyZCLCommand(_zm);
                gal.getApsManager().APSMessageIndication(messageEvent);

            }
        }

        /* APSDE-DATA.Confirm */
        else if (_command == FreescaleConstants.APSDEDataConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted APSDE-DATA.Confirm", message);

            /* DestAddress + DestEndPoint + SourceEndPoint */
            long destAddress = DataManipulation.toLong((byte) message[11], (byte) message[10],
                    (byte) message[9], (byte) message[8], (byte) message[7], (byte) message[6],
                    (byte) message[5], (byte) message[4]);
            byte destEndPoint = (byte) message[12];
            byte sourceEndPoint = (byte) message[13];
            String Key = String.format("%016X", destAddress) + String.format("%02X", destEndPoint)
                    + String.format("%02X", sourceEndPoint);

            // Found APSDE-DATA.Confirm. Remove the lock
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    /* DestAddress + DestEndPoint + SourceEndPoint */
                    /*
                     * if (gal.getPropertiesManager().getDebugEnabled())
                     * logger.info("APSDE-DATA.Confirm KEY SEND: " +
                     * pl.get_Key() + " -- KEY Received: " + Key);
                     */
                    if ((pl.getType() == TypeMessage.APS) && pl.get_Key().equalsIgnoreCase(Key)) {
                        synchronized (pl) {
                            pl.getStatus().setCode(message[14]);
                            pl.notify();
                        }
                        break;
                    }
                }
            }

        }

        /* ZTC-Error.event */
        else if (_command == FreescaleConstants.ZTCErrorevent) {

            byte len = (byte) message[2];
            String MessageStatus = "";
            if (len > 0) {
                int status = message[3];
                switch (status) {
                case 0x00:
                    MessageStatus = "0x00: gSuccess_c (Should not be seen in this event.)";
                    break;
                case 0xF4:
                    MessageStatus = "0xF4: gZtcOutOfMessages_c (ZTC tried to allocate a message, but the allocation failed.)";
                    break;
                case 0xF5:
                    MessageStatus = "0xF5: gZtcEndPointTableIsFull_c (Self explanatory.)";
                    break;
                case 0xF6:
                    MessageStatus = "0xF6: gZtcEndPointNotFound_c (Self explanatory.)";
                    break;
                case 0xF7:
                    MessageStatus = "0xF7: gZtcUnknownOpcodeGroup_c (ZTC does not recognize the opcode group, and there is no application hook.)";
                    break;
                case 0xF8:
                    MessageStatus = "0xF8: gZtcOpcodeGroupIsDisabled_c (ZTC support for an opcode group is turned off by a compile option.)";
                    break;
                case 0xF9:
                    MessageStatus = "0xF9: gZtcDebugPrintFailed_c (An attempt to print a debug message ran out of buffer space.)";
                    break;
                case 0xFA:
                    MessageStatus = "0xFA: gZtcReadOnly_c (Attempt to set read-only data.)";
                    break;
                case 0xFB:
                    MessageStatus = "0xFB: gZtcUnknownIBIdentifier_c (Self explanatory.)";
                    break;
                case 0xFC:
                    MessageStatus = "0xFC: gZtcRequestIsDisabled_c (ZTC support for an opcode is turned off by a compile option.)";
                    break;
                case 0xFD:
                    MessageStatus = "0xFD: gZtcUnknownOpcode_c (Self expanatory.)";
                    break;
                case 0xFE:
                    MessageStatus = "0xFE: gZtcTooBig_c (A data item to be set or retrieved is too big for the buffer available to hold it.)";
                    break;
                case 0xFF:
                    MessageStatus = "0xFF: gZtcError_c (Non-specific, catchall error code.)";
                    break;
                default:
                    break;
                }

            }
            String logMessage = "Extracted ZTC-ERROR.Event Status:" + MessageStatus;
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix(logMessage, message);
        }

        /* ZDP-Mgmt_Nwk_Update.Notify */

        else if (_command == FreescaleConstants.ZDPMgmt_Nwk_UpdateNotify) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted ZDP-Mgmt_Nwk_Update.Notify", message);

            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if (pl.getType() == TypeMessage.NWK_UPDATE) {

                        EnergyScanResult _result = new EnergyScanResult();

                        int _address = DataManipulation.toIntFromShort((byte) message[4], (byte) message[3]);

                        short _status = message[5];
                        if (_status == GatewayConstants.SUCCESS) {
                            byte[] _scannedChannel = new byte[4];
                            _scannedChannel[0] = (byte) message[9];
                            _scannedChannel[1] = (byte) message[8];
                            _scannedChannel[2] = (byte) message[7];
                            _scannedChannel[3] = (byte) message[6];

                            int _totalTrasmission = DataManipulation.toIntFromShort((byte) message[11],
                                    (byte) message[10]);

                            int _trasmissionFailure = DataManipulation.toIntFromShort((byte) message[13],
                                    (byte) message[12]);

                            short _scannedChannelListCount = message[14];
                            for (int i = 0; i < _scannedChannelListCount; i++) {
                                ScannedChannel _sc = new ScannedChannel();
                                // _sc.setChannel(value)
                                _sc.setEnergy(message[15 + i]);

                                _result.getScannedChannel().add(_sc);
                            }
                            synchronized (pl) {
                                pl.getStatus().setCode(message[7]);
                                pl.set_objectOfResponse(_result);
                                pl.notify();
                            }
                            break;

                        }

                    }
                }
            }

        }

        /* ZDP-SimpleDescriptor.Response */
        else if (_command == FreescaleConstants.ZDPSimpleDescriptorResponse) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted ZDP-ExtendedSimpleDescriptor.Response", message);
            /* Address + EndPoint */
            Address _add = new Address();

            _add.setNetworkAddress(DataManipulation.toIntFromShort((byte) message[5], (byte) message[4]));
            byte EndPoint = (byte) message[7];
            String Key = String.format("%04X", _add.getNetworkAddress()) + String.format("%02X", EndPoint);
            // Found ZDP-SimpleDescriptor.Response. Remove the lock
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    /* Address + EndPoint */
                    if ((pl.getType() == TypeMessage.GET_SIMPLE_DESCRIPTOR)
                            && pl.get_Key().equalsIgnoreCase(Key)) {

                        synchronized (pl) {
                            pl.getStatus().setCode(message[3]);
                            if (pl.getStatus().getCode() == GatewayConstants.SUCCESS) {

                                SimpleDescriptor _sp = new SimpleDescriptor();
                                _sp.setApplicationProfileIdentifier(
                                        DataManipulation.toIntFromShort((byte) message[9], (byte) message[8]));
                                _sp.setApplicationDeviceIdentifier(DataManipulation
                                        .toIntFromShort((byte) message[11], (byte) message[10]));
                                _sp.setApplicationDeviceVersion(message[12]);
                                int _index = 14;
                                short _numInpCluster = message[13];
                                for (int i = 0; i < _numInpCluster; i++) {
                                    _sp.getApplicationInputCluster().add(DataManipulation.toIntFromShort(
                                            (byte) message[_index + 1], (byte) message[_index]));
                                    _index = _index + 2;
                                }

                                short _numOutCluster = message[_index++];

                                for (int i = 0; i < _numOutCluster; i++) {
                                    _sp.getApplicationOutputCluster().add(DataManipulation.toIntFromShort(
                                            (byte) message[_index + 1], (byte) message[_index]));
                                    _index = _index + 2;
                                }
                                ServiceDescriptor _toRes = new ServiceDescriptor();
                                _toRes.setAddress(_add);
                                _toRes.setEndPoint(EndPoint);
                                _toRes.setSimpleDescriptor(_sp);
                                pl.set_objectOfResponse(_toRes);
                            }
                            pl.notify();
                        }
                        break;
                    }
                }
            }

        }

        /* APS-GetEndPointIdList.Confirm */
        else if (_command == FreescaleConstants.APSGetEndPointIdListConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted APS-GetEndPointIdList.Confirm", message);
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if ((pl.getType() == TypeMessage.GET_END_POINT_LIST)) {
                        synchronized (pl) {
                            pl.getStatus().setCode(message[3]);
                            NodeServices _res = new NodeServices();
                            if (pl.getStatus().getCode() == GatewayConstants.SUCCESS) {
                                short length = message[4];
                                for (int i = 0; i < length; i++) {
                                    ActiveEndpoints _ep = new ActiveEndpoints();
                                    _ep.setEndPoint(message[5 + i]);
                                    _res.getActiveEndpoints().add(_ep);
                                }
                            }
                            pl.set_objectOfResponse(_res);
                            pl.notify();
                        }
                        break;
                    }
                }
            }
        }

        /* ZDP-BIND.Response */
        else if (_command == FreescaleConstants.ZDPMgmtBindResponse) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted ZDP-BIND.Response", message);

            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if ((pl.getType() == TypeMessage.ADD_BINDING)) {
                        synchronized (pl) {
                            pl.getStatus().setCode(message[3]);
                            switch (pl.getStatus().getCode()) {
                            case GatewayConstants.SUCCESS:

                                break;

                            case 0x84:
                                pl.getStatus().setMessage("NOT_SUPPORTED (NOT SUPPORTED)");
                                break;

                            case 0x8C:
                                pl.getStatus().setMessage("TABLE_FULL (TABLE FULL)");
                                break;
                            case 0x8D:
                                pl.getStatus().setMessage("NOT_AUTHORIZED (NOT AUTHORIZED)");
                                break;
                            }
                            pl.notify();
                        }
                        break;
                    }
                }
            }
        }

        /* ZDP-UNBIND.Response */
        else if (_command == FreescaleConstants.ZDPUnbindResponse) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted ZDP-UNBIND.Response", message);

            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if ((pl.getType() == TypeMessage.REMOVE_BINDING)) {
                        synchronized (pl) {
                            pl.getStatus().setCode(message[3]);
                            switch (pl.getStatus().getCode()) {
                            case GatewayConstants.SUCCESS:

                                break;

                            case 0x84:
                                pl.getStatus().setMessage("NOT_SUPPORTED (NOT SUPPORTED)");
                                break;
                            case 0x88:
                                pl.getStatus().setMessage("No_Entry (No Entry)");
                                break;
                            case 0x8D:
                                pl.getStatus().setMessage("NOT_AUTHORIZED (NOT AUTHORIZED");
                                break;
                            }
                            pl.notify();
                        }
                        break;
                    }
                }
            }
        }

        /* ZDP-Mgmt_Bind.Response */
        else if (_command == FreescaleConstants.ZDPMgmt_BindResponse) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted ZDP-Mgmt_Bind.Response", message);

            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if ((pl.getType() == TypeMessage.GET_BINDINGS)) {
                        synchronized (pl) {
                            pl.getStatus().setCode(message[3]);
                            BindingList _res = new BindingList();

                            if (pl.getStatus().getCode() == GatewayConstants.SUCCESS) {
                                short length = message[6];
                                int _index = 6;
                                for (int i = 0; i < length; i++) {
                                    Binding _b = new Binding();
                                    long src_longAddress = DataManipulation.toLong((byte) message[_index + 8],
                                            (byte) message[_index + 7], (byte) message[_index + 6],
                                            (byte) message[_index + 5], (byte) message[_index + 4],
                                            (byte) message[_index + 3], (byte) message[_index + 2],
                                            (byte) message[_index + 1]);
                                    short _srcEP = message[_index + 9];

                                    int _cluster = DataManipulation.toIntFromShort((byte) message[_index + 11],
                                            (byte) message[_index + 10]);

                                    short _DestinationMode = message[_index + 12];
                                    Device _dev = new Device();

                                    if (_DestinationMode == 0x03) {

                                        long dst_longAddress = DataManipulation.toLong(
                                                (byte) message[_index + 20], (byte) message[_index + 19],
                                                (byte) message[_index + 18], (byte) message[_index + 17],
                                                (byte) message[_index + 16], (byte) message[_index + 15],
                                                (byte) message[_index + 14], (byte) message[_index + 13]);

                                        short _dstEP = message[_index + 21];
                                        _dev.setAddress(BigInteger.valueOf(dst_longAddress));
                                        _dev.setEndpoint(_dstEP);
                                        _index = _index + 21;
                                    } else if (_DestinationMode == 0x01) {

                                        int _groupId = DataManipulation.toIntFromShort(
                                                (byte) message[_index + 14], (byte) message[_index + 13]);
                                        _dev.setAddress(BigInteger.valueOf(_groupId));
                                        _index = _index + 10;
                                    }
                                    _b.setClusterID(_cluster);
                                    _b.setSourceEndpoint(_srcEP);
                                    _b.setSourceIEEEAddress(BigInteger.valueOf(src_longAddress));

                                    _b.getDeviceDestination().add(_dev);
                                    _res.getBinding().add(_b);

                                }
                            }
                            pl.set_objectOfResponse(_res);
                            pl.notify();
                        }
                        break;
                    }
                }
            }
        }

        /* APS-DeregisterEndPoint.Confirm */
        else if (_command == FreescaleConstants.APSDeRegisterEndPointConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted APS-DeregisterEndPoint.Confirm", message);
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if ((pl.getType() == TypeMessage.DEREGISTER_END_POINT)) {
                        synchronized (pl) {
                            pl.getStatus().setCode(message[3]);
                            pl.notify();
                        }
                        break;
                    }
                }
            }

        }

        /* APS-ZDP-Mgmt_Lqi.Response */
        else if (_command == FreescaleConstants.ZDPMgmtLqiResponse) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix(
                        "Extracted ZDP-Mgmt_Lqi.Response... waiting the related Indication ZDO", message);

        }
        /* ZTC-ReadExtAddr.Confirm */
        else if (_command == FreescaleConstants.ZTCReadExtAddrConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted ZTC-ReadExtAddr.Confirm", message);
            long longAddress = DataManipulation.toLong((byte) message[11], (byte) message[10],
                    (byte) message[9], (byte) message[8], (byte) message[7], (byte) message[6],
                    (byte) message[5], (byte) message[4]);
            BigInteger _bi = BigInteger.valueOf(longAddress);
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if ((pl.getType() == TypeMessage.READ_EXT_ADDRESS)) {
                        synchronized (pl) {
                            pl.set_objectOfResponse(_bi);
                            pl.getStatus().setCode(message[3]);
                            pl.notify();
                        }
                        break;
                    }
                }
            }

        }

        /* ZDP-IEEE_addr.response */
        else if (_command == FreescaleConstants.ZDPIeeeAddrResponse) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted ZDP-IEEE_addr.response", message);
            long longAddress = DataManipulation.toLong((byte) message[11], (byte) message[10],
                    (byte) message[9], (byte) message[8], (byte) message[7], (byte) message[6],
                    (byte) message[5], (byte) message[4]);
            BigInteger _bi = BigInteger.valueOf(longAddress);
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if ((pl.getType() == TypeMessage.READ_IEEE_ADDRESS)) {
                        synchronized (pl) {
                            pl.set_objectOfResponse(_bi);
                            pl.getStatus().setCode(message[3]);
                            pl.notify();
                        }
                        break;
                    }
                }
            }

        }
        /* ZDP-Mgmt_Leave.Response */
        else if (_command == FreescaleConstants.ZDPMgmtLeaveResponse) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted ZDP-Mgmt_Leave.Response", message);

        }
        /* ZDP-Active_EP_rsp.response */
        else if (_command == FreescaleConstants.ZDPActiveEpResponse) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted ZDP-Active_EP_rsp.response", message);
            short Status = message[3];
            Address _add = new Address();

            _add.setNetworkAddress(DataManipulation.toIntFromShort((byte) message[5], (byte) message[4]));
            String Key = String.format("%04X", _add.getNetworkAddress());
            List<Short> _toRes = null;

            NodeServices _node = new NodeServices();
            _node.setAddress(_add);

            switch (Status) {
            case 0x00:
                _toRes = new ArrayList<Short>();
                int _EPCount = message[6];

                for (int i = 0; i < _EPCount; i++) {
                    _toRes.add(message[7 + i]);
                    ActiveEndpoints _aep = new ActiveEndpoints();
                    _aep.setEndPoint(message[7 + i]);
                    _node.getActiveEndpoints().add(_aep);

                }
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info("ZDP-Active_EP_rsp.response status:00 - Success");
                }
                break;
            case 0x80:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info("ZDP-Active_EP_rsp.response status:80 - Inv_RequestType");
                }
                break;
            case 0x89:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info("ZDP-Active_EP_rsp.response status:89 - No_Descriptor");
                }
                break;
            case 0x81:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info("ZDP-Active_EP_rsp.response status:81 - Device_Not_found");
                }
                break;
            }
            // Found ZDP-Active_EP_rsp.response. Remove the lock
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    /* DestAddress */
                    if ((pl.getType() == TypeMessage.ACTIVE_EP) && pl.get_Key().equalsIgnoreCase(Key)) {
                        synchronized (pl) {
                            pl.set_objectOfResponse(_toRes);
                            pl.getStatus().setCode(Status);
                            pl.notify();

                        }
                        break;
                    }
                }
            }

        }

        /* ZDP-StopNwkEx.Confirm */
        else if (_command == FreescaleConstants.ZTCStopNwkExConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted ZDP-StopNwkEx.Confirm", message);
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if (pl.getType() == TypeMessage.STOP_NETWORK) {
                        if (message[3] == 0x00) {
                            gal.get_gatewayEventManager().notifyGatewayStopResult(makeStatusObject(
                                    "The stop command has been processed byt ZDO with success.", (short) 0x00));
                            synchronized (gal) {
                                gal.setGatewayStatus(GatewayStatus.GW_STOPPING);
                            }
                        }
                        synchronized (pl) {
                            pl.getStatus().setCode(message[3]);
                            pl.notify();
                        }
                        break;
                    }
                }
            }

        }
        /* NLME-GET.Confirm */
        else if (_command == FreescaleConstants.NLMEGetConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted NLME-GET.Confirm", message);
            String _Key = String.format("%02X", message[4]);
            // Found APSDE-DATA.Confirm. Remove the lock
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if (pl.getType() == TypeMessage.NMLE_GET && pl.get_Key().equalsIgnoreCase(_Key)) {
                        short _Length = (short) DataManipulation.toIntFromShort((byte) message[9],
                                (byte) message[8]);
                        byte[] _res = DataManipulation.subByteArray(message, 10, _Length + 9);
                        if (_Length >= 2)
                            _res = DataManipulation.reverseBytes(_res);
                        synchronized (pl) {
                            pl.getStatus().setCode(message[3]);
                            pl.set_objectOfResponse(DataManipulation.convertBytesToString(_res));
                            pl.notify();
                        }
                        break;
                    }
                }
            }

        }
        /* APSME_GET.Confirm */
        else if (_command == FreescaleConstants.APSMEGetConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted APSME_GET.Confirm", message);
            String _Key = String.format("%02X", message[4]);
            // Found APSME_GET-DATA.Confirm. Remove the lock
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if (pl.getType() == TypeMessage.APSME_GET && pl.get_Key().equalsIgnoreCase(_Key)) {
                        short _Length = (short) DataManipulation.toIntFromShort((byte) message[9],
                                (byte) message[8]);
                        byte[] _res = DataManipulation.subByteArray(message, 10, _Length + 9);
                        if (_Length >= 2)
                            _res = DataManipulation.reverseBytes(_res);
                        synchronized (pl) {
                            pl.getStatus().setCode(message[3]);
                            pl.set_objectOfResponse(DataManipulation.convertBytesToString(_res));
                            pl.notify();
                        }
                        break;
                    }
                }
            }

        }
        // ZDP-StartNwkEx.Confirm
        else if (_command == FreescaleConstants.ZTCStartNwkExConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted ZDP-StartNwkEx.Confirm", message);
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if (pl.getType() == TypeMessage.START_NETWORK) {
                        if (message[3] == 0x00) {
                            gal.setGatewayStatus(GatewayStatus.GW_STARTED);
                        }
                        synchronized (pl) {
                            pl.getStatus().setCode(message[3]);
                            pl.notify();
                        }
                        break;
                    }
                }
            }
        }

        /* APS-RegisterEndPoint.Confirm */
        else if (_command == FreescaleConstants.APSRegisterEndPointConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted APS-RegisterEndPoint.Confirm", message);
            // Found APS-RegisterEndPoint.Confirm. Remove the lock
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if (pl.getType() == TypeMessage.CONFIGURE_END_POINT) {
                        synchronized (pl) {
                            pl.getStatus().setCode(message[3]);
                            pl.notify();
                        }
                        break;
                    }
                }
            }
        }
        /* ZTC-ModeSelect.Confirm */
        else if (_command == FreescaleConstants.ZTCModeSelectConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted ZTC-ModeSelect.Confirm", message);
            short status = message[3];
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if (pl.getType() == TypeMessage.MODE_SELECT) {
                        synchronized (pl) {
                            pl.getStatus().setCode(status);
                            pl.notify();
                        }
                        break;
                    }
                }
            }
        }
        /* MacGetPIBAttribute.Confirm */
        else if (_command == FreescaleConstants.MacGetPIBAttributeConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted MacGetPIBAttribute.Confirm", message);
        }
        /* MacBeaconNotify.Indication */
        else if (_command == FreescaleConstants.MacBeaconNotifyIndication) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted MacBeaconNotify.Indication", message);
        }
        /* MacBeaconStart.Indication */
        else if (_command == FreescaleConstants.MacPollNotifyIndication) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted MacBeaconStart.Indication", message);
        }
        /* NLME-NETWORK-FORMATION.Confirmn */
        else if (_command == FreescaleConstants.NLMENETWORKFORMATIONConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted NLME-NETWORK-FORMATION.Confirm", message);
        }
        /* NLME-START-ROUTER.Request */
        else if (_command == FreescaleConstants.NLMESTARTROUTERRequest) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted NLME-NETWORK-FORMATION.Confirm", message);
        }
        /* MacStart.Request */
        else if (_command == FreescaleConstants.MacStartRequest) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted MacStart.Request", message);
        }
        /* MacStart.Confirm */
        else if (_command == FreescaleConstants.MacStartConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted MacStart.Confirm", message);
        }
        /* NLME-START-ROUTER.Confirm */
        else if (_command == FreescaleConstants.NLMESTARTROUTERConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted NLME-START-ROUTER.Confirm", message);
        }
        /* NWK-ProcessSecureFrame.Report */
        else if (_command == FreescaleConstants.NWKProcessSecureFrameReport) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted NWK-ProcessSecureFrame.Report", message);
        }
        /* ZDP-Nwk-ProcessSecureFrame.Confirm */
        else if (_command == FreescaleConstants.ZDPNwkProcessSecureFrameConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted ZDP-Nwk-ProcessSecureFrame.Confirm", message);
        }

        /* BlackBox.WriteSAS.Confirm */
        else if (_command == FreescaleConstants.BlackBoxWriteSASConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted BlackBox.WriteSAS.Confirm", message);
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if (pl.getType() == TypeMessage.WRITE_SAS) {
                        synchronized (pl) {
                            pl.getStatus().setCode(message[3]);
                            pl.notify();
                        }
                        break;
                    }
                }
            }
        }
        /* ZTC-GetChannel.Confirm */
        else if (_command == FreescaleConstants.ZTCGetChannelConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted ZTC-GetChannel.Confirm", message);
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if (pl.getType() == TypeMessage.CHANNEL_REQUEST) {
                        synchronized (pl) {
                            pl.getStatus().setCode(message[3]);
                            pl.set_objectOfResponse(message[4]);
                            pl.notify();
                        }
                        break;
                    }
                }
            }
        }

        /* ZDP-NodeDescriptor.Response */
        else if (_command == FreescaleConstants.ZDPNodeDescriptorResponse) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted ZDP-NodeDescriptor.Response", message);
            int _NWKAddressOfInterest = DataManipulation.toIntFromShort((byte) message[5], (byte) message[4]);
            Address _addressOfInterst = new Address();
            _addressOfInterst.setNetworkAddress(_NWKAddressOfInterest);
            NodeDescriptor _node = new NodeDescriptor();

            /* First Byte */
            byte _first = (byte) message[6];
            byte _Logical_byte = (byte) (_first & 0x07);/* Bits 0,1,2 */
            byte _ComplexDescriptorAvalilable = (byte) ((_first & 0x08) >> 3);/* Bit3 */
            byte _UserDescriptorAvalilable = (byte) ((_first & 0x0A) >> 4);/* Bit4 */
            switch (_Logical_byte) {
            case FreescaleConstants.LogicalType.Coordinator:
                _node.setLogicalType(LogicalType.COORDINATOR);
                break;
            case FreescaleConstants.LogicalType.Router:
                _node.setLogicalType(LogicalType.ROUTER);
                break;
            case FreescaleConstants.LogicalType.EndDevice:
                _node.setLogicalType(LogicalType.END_DEVICE);
                break;
            default:
                throw new Exception("LogicalType is not valid value");
            }
            _node.setComplexDescriptorAvailable((_ComplexDescriptorAvalilable == 1 ? true : false));
            _node.setUserDescriptorAvailable((_UserDescriptorAvalilable == 1 ? true : false));

            /* Second Byte */
            byte _second = (byte) message[7];
            /* Aps flags bits 0,1,2 */
            byte _FrequencyBand = (byte) ((_second & 0xF8) >> 0x03);/*
                                                                    * bits
                                                                    * 3
                                                                    * ,4,5,
                                                                    * 6,7
                                                                    */
            switch (_FrequencyBand) {
            case 0x01:
                _node.setFrequencyBand("868MHz");
                break;
            case 0x04:
                _node.setFrequencyBand("900MHz");
                break;
            case 0x08:
                _node.setFrequencyBand("2400MHz");
                break;
            default:
                _node.setFrequencyBand("Reserved");
                break;
            }

            /* MACcapabilityFlags_BYTE Byte */
            byte _MACcapabilityFlags_BYTE = (byte) message[8];
            MACCapability _maccapability = new MACCapability();
            byte _AlternatePanCoordinator = (byte) (_MACcapabilityFlags_BYTE & 0x01);/* Bit0 */
            byte _DeviceIsFFD = (byte) ((_MACcapabilityFlags_BYTE & 0x02) >> 1);/* Bit1 */
            byte _MainsPowered = (byte) ((_MACcapabilityFlags_BYTE & 0x04) >> 2);/* Bit2 */
            byte _ReceiverOnWhenIdle = (byte) ((_MACcapabilityFlags_BYTE & 0x08) >> 3);/* Bit3 */
            // bit 4-5 reserved
            byte _SecuritySupported = (byte) ((_MACcapabilityFlags_BYTE & 0x40) >> 6);/* Bit6 */
            byte _AllocateAddress = (byte) ((_MACcapabilityFlags_BYTE & 0x80) >> 7);/* Bit7 */
            _maccapability.setAlternatePanCoordinator((_AlternatePanCoordinator == 1 ? true : false));
            _maccapability.setDeviceIsFFD((_DeviceIsFFD == 1 ? true : false));
            _maccapability.setMainsPowered((_MainsPowered == 1 ? true : false));
            _maccapability.setReceiverOnWhenIdle((_ReceiverOnWhenIdle == 1 ? true : false));
            _maccapability.setSecuritySupported((_SecuritySupported == 1 ? true : false));
            _maccapability.setAllocateAddress((_AllocateAddress == 1 ? true : false));
            _node.setMACCapabilityFlag(_maccapability);

            /* ManufacturerCode_BYTES */
            int _ManufacturerCode_BYTES = DataManipulation.toIntFromShort((byte) message[10],
                    (byte) message[9]);
            _node.setManufacturerCode(_ManufacturerCode_BYTES);

            /* MaximumBufferSize_BYTE */
            short _MaximumBufferSize_BYTE = message[11];
            _node.setMaximumBufferSize(_MaximumBufferSize_BYTE);

            /* MaximumTransferSize_BYTES */
            int _MaximumTransferSize_BYTES = DataManipulation.toIntFromShort((byte) message[13],
                    (byte) message[12]);
            _node.setMaximumIncomingTransferSize(_MaximumTransferSize_BYTES);

            /* ServerMask_BYTES */
            int _ServerMask_BYTES = DataManipulation.toIntFromShort((byte) message[15], (byte) message[14]);
            ServerMask _serverMask = new ServerMask();
            byte _PrimaryTrustCenter = (byte) (_ServerMask_BYTES & 0x01);/* Bit0 */
            byte _BackupTrustCenter = (byte) ((_ServerMask_BYTES & 0x02) >> 1);/* Bit1 */
            byte _PrimaryBindingTableCache = (byte) ((_ServerMask_BYTES & 0x04) >> 2);/* Bit2 */
            byte _BackupBindingTableCache = (byte) ((_ServerMask_BYTES & 0x08) >> 3);/* Bit3 */
            byte _PrimaryDiscoveryCache = (byte) ((_ServerMask_BYTES & 0x10) >> 4);/* Bit4 */
            byte _BackupDiscoveryCache = (byte) ((_ServerMask_BYTES & 0x20) >> 5);/* Bit5 */
            _serverMask.setPrimaryTrustCenter((_PrimaryTrustCenter == 1 ? true : false));
            _serverMask.setBackupTrustCenter((_BackupTrustCenter == 1 ? true : false));
            _serverMask.setPrimaryBindingTableCache((_PrimaryBindingTableCache == 1 ? true : false));
            _serverMask.setBackupBindingTableCache((_BackupBindingTableCache == 1 ? true : false));
            _serverMask.setPrimaryDiscoveryCache((_PrimaryDiscoveryCache == 1 ? true : false));
            _serverMask.setBackupDiscoveryCache((_BackupDiscoveryCache == 1 ? true : false));
            _node.setServerMask(_serverMask);

            /* MaximumOutTransferSize_BYTES */
            int _MaximumOutTransferSize_BYTES = DataManipulation.toIntFromShort((byte) message[17],
                    (byte) message[16]);
            _node.setMaximumOutgoingTransferSize(_MaximumOutTransferSize_BYTES);

            /* CapabilityField_BYTES */
            byte _CapabilityField_BYTES = (byte) message[18];
            DescriptorCapability _DescriptorCapability = new DescriptorCapability();
            byte _ExtendedActiveEndpointListAvailable = (byte) (_CapabilityField_BYTES & 0x01);/* Bit0 */
            byte _ExtendedSimpleDescriptorListAvailable = (byte) ((_CapabilityField_BYTES
                    & 0x02) >> 1);/* Bit1 */
            _DescriptorCapability.setExtendedActiveEndpointListAvailable(
                    (_ExtendedActiveEndpointListAvailable == 1 ? true : false));
            _DescriptorCapability.setExtendedSimpleDescriptorListAvailable(
                    (_ExtendedSimpleDescriptorListAvailable == 1 ? true : false));
            _node.setDescriptorCapabilityField(_DescriptorCapability);
            String _key = String.format("%04X", _NWKAddressOfInterest);
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if (pl.getType() == TypeMessage.NODE_DESCRIPTOR && pl.get_Key().equalsIgnoreCase(_key)) {
                        synchronized (pl) {
                            pl.getStatus().setCode(message[3]);/* Status */
                            pl.set_objectOfResponse(_node);
                            pl.notify();
                        }
                        break;
                    }
                }
            }
        }
        /* NMLE-SET.Confirm */
        else if (_command == FreescaleConstants.NMLESETConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted NMLE-SET.Confirm", message);
            short status = message[3];
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if (pl.getType() == TypeMessage.NMLE_SET) {

                        synchronized (pl) {
                            pl.getStatus().setCode(status);
                            pl.notify();
                        }
                        break;
                    }
                }
            }
        }
        /* APSME-SET.Confirm */
        else if (_command == FreescaleConstants.APSMESetConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted APSME-SET.Confirm", message);
            short status = message[3];
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if (pl.getType() == TypeMessage.APSME_SET) {

                        synchronized (pl) {
                            pl.getStatus().setCode(status);
                            pl.notify();
                        }
                        break;
                    }
                }
            }
        }

        /* ZDP-Mgmt_Permit_Join.response */
        else if (_command == FreescaleConstants.ZDPMgmt_Permit_JoinResponse) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted ZDP-Mgmt_Permit_Join.response", message);
            short status = message[3];
            String mess = "";

            switch (status) {
            case 0x00:

                break;
            case 0x80:
                mess = "InvRequestType";
                break;
            case 0x84:
                mess = "Not Supported";
                break;
            case 0x87:
                mess = "Table Full";
                break;
            case 0x8D:
                mess = "NOT AUTHORIZED";
                break;
            case 0xC5:
                mess = "Already present in the network";
                break;

            }
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if (pl.getType() == TypeMessage.PERMIT_JOIN) {
                        synchronized (pl) {
                            pl.getStatus().setCode(status);
                            pl.getStatus().setMessage(mess);
                            pl.notify();
                        }
                        break;
                    }
                }

            }
        }

        /* APS-ClearDeviceKeyPairSet.Confirm */
        else if (_command == FreescaleConstants.APSClearDeviceKeyPairSetConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("APS-ClearDeviceKeyPairSet.Confirm", message);
            short status = message[3];
            String mess = "";
            switch (status) {
            case 0x00:

                break;
            }
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if (pl.getType() == TypeMessage.CLEAR_DEVICE_KEY_PAIR_SET) {
                        synchronized (pl) {
                            pl.getStatus().setCode(status);
                            pl.getStatus().setMessage(mess);
                            pl.notify();
                        }
                        break;
                    }
                }

            }

        }

        /* ZTC-ClearNeighborTableEntry.Confirm */
        else if (_command == FreescaleConstants.ZTCClearNeighborTableEntryConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("ZTC-ClearNeighborTableEntry.Confirm", message);
            short status = message[3];
            String mess = "";
            switch (status) {
            case 0x00:

                break;
            }
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if (pl.getType() == TypeMessage.CLEAR_NEIGHBOR_TABLE_ENTRY) {
                        synchronized (pl) {
                            pl.getStatus().setCode(status);
                            pl.getStatus().setMessage(mess);
                            pl.notify();
                        }
                        break;
                    }
                }

            }

        }

        /* NLME-JOIN.Confirm */
        else if (_command == FreescaleConstants.NLMEJOINConfirm) {
            short _status = message[8];
            switch (_status) {
            case 0x00:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info("Extracted NLME-JOIN.Confirm: SUCCESS (Joined the network)");
                }
                break;
            case 0xC2:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info("Extracted NLME-JOIN.Confirm: INVALID_REQUEST (Not Valid Request)");
                }
                break;
            case 0xC3:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info("Extracted NLME-JOIN.Confirm: NOT_PERMITTED (Not allowed to join the network)");
                }
                break;
            case 0xCA:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info("Extracted NLME-JOIN.Confirm: NO_NETWORKS (Network not found)");
                }
                break;
            case 0x01:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info("Extracted NLME-JOIN.Confirm: PAN_AT_CAPACITY (PAN at capacity)");
                }
                break;
            case 0x02:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info("Extracted NLME-JOIN.Confirm: PAN_ACCESS_DENIED (PAN access denied)");
                }
                break;
            case 0xE1:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info(
                            "Extracted NLME-JOIN.Confirm: CHANNEL_ACCESS_FAILURE (Transmission failed due to activity on the channel)");
                }
                break;
            case 0xE4:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info(
                            "Extracted NLME-JOIN.Confirm: FAILED_SECURITY_CHECK (The received frame failed security check)");
                }
                break;
            case 0xE8:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info(
                            "Extracted NLME-JOIN.Confirm: INVALID_PARAMETER (A parameter in the primitive is out of the valid range)");
                }
                break;
            case 0xE9:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info("Extracted NLME-JOIN.Confirm: NO_ACK (Acknowledgement was not received)");
                }
                break;
            case 0xEB:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info(
                            "Extracted NLME-JOIN.Confirm: NO_DATA (No response data was available following a request)");
                }
                break;
            case 0xF3:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info(
                            "Extracted NLME-JOIN.Confirm: UNAVAILABLE_KEY (The appropriate key is not available in the ACL)");
                }
                break;
            case 0xEA:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info("Extracted NLME-JOIN.Confirm: NO_BEACON (No Networks)");
                }
                break;
            default:
                throw new Exception("Extracted NLME-JOIN.Confirm: Invalid Status - " + _status);
            }
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("NLME-JOIN.Confirm", message);
        }

        /* ZDO-NetworkState.Event */
        else if (_command == FreescaleConstants.ZDONetworkStateEvent) {
            short _status = message[3];
            String mess;
            switch (_status) {
            case 0x00:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info("Extracted ZDO-NetworkState.Event: DeviceInitialized (Device Initialized)");
                }
                break;
            case 0x01:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info(
                            "Extracted ZDO-NetworkState.Event: DeviceinNetworkDiscoveryState (Device in Network Discovery State)");
                }
                break;
            case 0x02:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info(
                            "Extracted ZDO-NetworkState.Event: DeviceJoinNetworkstate (Device Join Network state)");
                }
                break;
            case 0x03:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info(
                            "Extracted ZDO-NetworkState.Event: DeviceinCoordinatorstartingstate (Device in Coordinator starting state)");
                }
                gal.setGatewayStatus(GatewayStatus.GW_STARTING);
                break;
            case 0x04:
                mess = "ZDO-NetworkState.Event: DeviceinRouterRunningstate (Device in Router Running state)";
                gal.get_gatewayEventManager().notifyGatewayStartResult(makeStatusObject(mess, _status));
                gal.setGatewayStatus(GatewayStatus.GW_RUNNING);
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info(mess);
                }
                break;
            case 0x05:
                mess = "ZDO-NetworkState.Event: DeviceinEndDeviceRunningstate (Device in End Device Running state)";
                gal.get_gatewayEventManager().notifyGatewayStartResult(makeStatusObject(mess, _status));
                gal.setGatewayStatus(GatewayStatus.GW_RUNNING);

                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info(mess);
                }
                break;
            case 0x09:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info(
                            "Extracted ZDO-NetworkState.Event: Deviceinleavenetworkstate (Device in leave network state)");
                }

                gal.setGatewayStatus(GatewayStatus.GW_STOPPING);
                break;
            case 0x0A:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info(
                            "Extracted ZDO-NetworkState.Event: Deviceinauthenticationstate (Device in authentication state)");
                }
                break;
            case 0x0B:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info(
                            "Extracted ZDO-NetworkState.Event: Deviceinstoppedstate (Device in stopped state)");
                }
                gal.setGatewayStatus(GatewayStatus.GW_STOPPED);

                break;
            case 0x0C:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info(
                            "Extracted ZDO-NetworkState.Event: DeviceinOrphanjoinstate (Device in Orphan join state)");
                }
                break;
            case 0x10:
                mess = "ZDO-NetworkState.Event: DeviceinCoordinatorRunningstate (Device is Coordinator Running state)";

                gal.get_gatewayEventManager().notifyGatewayStartResult(makeStatusObject(mess, _status));
                gal.setGatewayStatus(GatewayStatus.GW_RUNNING);
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info(mess);
                }
                break;
            case 0x11:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info(
                            "Extracted ZDO-NetworkState.Event: DeviceinKeytransferstate (Device in Key transfer state)");
                }
                break;
            case 0x12:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info(
                            "Extracted ZDO-NetworkState.Event: Deviceinauthenticationstate (Device in authentication state)");
                }
                break;
            case 0x13:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info(
                            "Extracted ZDO-NetworkState.Event: DeviceOfftheNetwork (Device Off the Network)");
                }
                break;
            default:
                throw new Exception("ZDO-NetworkState.Event: Invalid Status - " + _status);
            }
        }
        /* MacSetPIBAttribute.Confirm */
        else if (_command == FreescaleConstants.MacSetPIBAttributeConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted MacSetPIBAttribute.Confirm", message);
        }
        /* NLME-ENERGY-SCAN.Request */
        else if (_command == FreescaleConstants.NLMEENERGYSCANRequest) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted NLME-ENERGY-SCAN.Request", message);
        }
        /* MacScan.Request */
        else if (_command == FreescaleConstants.MacScanRequest) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted MacScan.Request", message);
        }
        /* MacScan.Confirm */
        else if (_command == FreescaleConstants.MacScanConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted MacScan.Confirm", message);
        }
        /* NLME-ENERGY-SCAN.confirm */
        else if (_command == FreescaleConstants.NLMEENERGYSCANconfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted NLME-ENERGY-SCAN.confirm", message);
        }
        /* NLME-NETWORK-DISCOVERY.Request */
        else if (_command == FreescaleConstants.NLMENETWORKDISCOVERYRequest) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted NLME-NETWORK-DISCOVERY.Request", message);
        }
        /* MacScan.Request */
        else if (_command == FreescaleConstants.MacScanRequest) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted MacScan.Request", message);
        }
        /* NLME-NETWORK-DISCOVERY.Confirm */
        else if (_command == FreescaleConstants.NLMENetworkDiscoveryConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted NLME-NETWORK-DISCOVERY.Confirm", message);
        }
        /* NLME-NETWORK-FORMATION.Request */
        else if (_command == FreescaleConstants.NLMENETWORKFORMATIONRequest) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted NLME-NETWORK-FORMATION.Request", message);
        }
        /* NLME-SET.Request */
        else if (_command == FreescaleConstants.NLMESetRequest) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted NLME-SET.Request", message);
        }
        /* NLME-NWK-STATUS.Indication */
        else if (_command == FreescaleConstants.NLMENwkStatusIndication) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("NLME-NWK-STATUS.Indication", message);
        }
        /* NLME-ROUTE-DISCOVERY.confirm */
        else if (_command == FreescaleConstants.NLMENWKSTATUSIndication) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("NLME-ROUTE-DISCOVERY.confirm", message);
        } else {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted a Message not in Message Management", message);
        }

        synchronized (this) {
            _size = messages.size();
        }
    }

}