// Overridden by LTMessageDecoder.
protected Message createMessage(DirectByteBuffer ref_buff) throws MessageException {
try {
return BTMessageFactory.createBTMessage(ref_buff);
} catch (MessageException me) {
/*if (identifier != null && me.getMessage() != null && me.getMessage().startsWith("Unknown BT message id")) {
System.out.println(identifier + " " + me.getMessage());
}*/
throw me;
}
}
private int postReadProcess() throws IOException {
int prot_bytes_read = 0;
int data_bytes_read = 0;
if (!reading_length_mode && !destroyed) { // reading payload data mode
// ensure-restore proper buffer limits
payload_buffer.limit(SS, message_length);
length_buffer.limit(SS, 4);
int read = payload_buffer.position(SS) - pre_read_start_position;
if (payload_buffer.position(SS) > 0) { // need to have read the message id first byte
if (BTMessageFactory.getMessageType(payload_buffer) == Message.TYPE_DATA_PAYLOAD) {
data_bytes_read += read;
} else {
prot_bytes_read += read;
}
}
if (!payload_buffer.hasRemaining(SS) && !is_paused) { // full message received!
payload_buffer.position(SS, 0);
DirectByteBuffer ref_buff = payload_buffer;
payload_buffer = null;
if (reading_handshake_message) { // decode handshake
reading_handshake_message = false;
DirectByteBuffer handshake_data =
DirectByteBufferPool.getBuffer(DirectByteBuffer.AL_MSG_BT_HAND, 68);
handshake_data.putInt(SS, HANDSHAKE_FAKE_LENGTH);
handshake_data.put(SS, ref_buff);
handshake_data.flip(SS);
ref_buff.returnToPool();
try {
Message handshake =
MessageManager.getSingleton()
.createMessage(BTMessage.ID_BT_HANDSHAKE_BYTES, handshake_data, (byte) 1);
messages_last_read.add(handshake);
} catch (MessageException me) {
handshake_data.returnToPool();
throw new IOException("BT message decode failed: " + me.getMessage());
}
// we need to auto-pause decoding until we're told to start again externally,
// as we don't want to accidentally read the next message on the stream if it's an
// AZ-format handshake
pauseDecoding();
} else { // decode normal message
try {
messages_last_read.add(createMessage(ref_buff));
} catch (Throwable e) {
ref_buff.returnToPoolIfNotFree();
// maintain unexpected errors as such so they get logged later
if (e instanceof RuntimeException) {
throw ((RuntimeException) e);
}
throw new IOException("BT message decode failed: " + e.getMessage());
}
}
reading_length_mode = true; // see if we've already read the next message's length
percent_complete = -1; // reset receive percentage
} else { // only partial received so far
percent_complete =
(payload_buffer.position(SS) * 100) / message_length; // compute receive percentage
}
}
if (reading_length_mode && !destroyed) {
length_buffer.limit(SS, 4); // ensure proper buffer limit
prot_bytes_read +=
(pre_read_start_buffer == 1)
? length_buffer.position(SS) - pre_read_start_position
: length_buffer.position(SS);
if (!length_buffer.hasRemaining(SS)) { // done reading the length
reading_length_mode = false;
length_buffer.position(SS, 0);
message_length = length_buffer.getInt(SS);
length_buffer.position(SS, 0); // reset it for next length read
if (message_length == HANDSHAKE_FAKE_LENGTH) { // handshake message
reading_handshake_message = true;
message_length = 64; // restore 'real' length
payload_buffer =
DirectByteBufferPool.getBuffer(DirectByteBuffer.AL_MSG_BT_HAND, message_length);
} else if (message_length == 0) { // keep-alive message
reading_length_mode = true;
last_received_was_keepalive = true;
try {
Message keep_alive =
MessageManager.getSingleton()
.createMessage(BTMessage.ID_BT_KEEP_ALIVE_BYTES, null, (byte) 1);
messages_last_read.add(keep_alive);
} catch (MessageException me) {
throw new IOException("BT message decode failed: " + me.getMessage());
}
} else if (message_length < MIN_MESSAGE_LENGTH || message_length > MAX_MESSAGE_LENGTH) {
throw new IOException(
"Invalid message length given for BT message decode: " + message_length);
} else { // normal message
payload_buffer =
DirectByteBufferPool.getBuffer(DirectByteBuffer.AL_MSG_BT_PAYLOAD, message_length);
}
}
}
protocol_bytes_last_read += prot_bytes_read;
data_bytes_last_read += data_bytes_read;
return prot_bytes_read + data_bytes_read;
}