Develop Reference

How to send data continuosly from arduino to android app through esp8266

I'm trying to send data from arduino to android app through esp8266. For the moment, arduino and android app are connected via the esp8266 using the TCP/IP socket API. However, when trying to send data continuosly from the arduino it's recieved only once by the android app. In fact, the message is well received by the app only when I proceed the AT+CLOSE command to close the socket and end communication. This method enables me to get the data only one time. So, I have tried to try configure the communication another time after closing it ( please check my code)
void loop()
{
if(Serial1.available())
{
Serial.println("heeeere");
int connectionId = Serial1.read()-48;
while(analogRead(4)>0)
{
convertedvalue = String((analogRead(4)*5)/1024); //convert read analog value before sending it to the android app
convertedvaluelength = String(convertedvalue.length()); //get the length of the converted value
content = "Converted value is "; //make the response to be send to the android app
content += convertedvalue; //make the response to be send to the android app
sendCIPData(connectionId,content);
sendData("AT+CIPCLOSE=0\r\n",1000,DEBUG); //close the connection
delay(10000);
sendData("AT+CIPSERVER=0\r\n",1000,DEBUG); // turn off server
delay(10000);
sendData("AT+CIPSERVER=1,80\r\n",1000,DEBUG); // turn on server on port 80
delay(10000);
}
}
}
Android code :
package com.example.youssefguirat.socketseverywhere;
import android.app.Activity;
import android.os.AsyncTask;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.Socket;
import java.net.UnknownHostException;
class Client extends AsyncTask<Void, Void, Void> {
String dstAddress;
int dstPort;
String response = "";
TextView textResponse;
Client(String addr, int port,TextView textResponse) {
dstAddress = addr;
dstPort = port;
this.textResponse=textResponse;
}
#Override
protected Void doInBackground(Void... arg0) {
Socket socket = null;
try {
socket = new Socket(dstAddress, dstPort);
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(
1024);
byte[] buffer = new byte[1024];
int bytesRead;
InputStream inputStream = socket.getInputStream();
socket.sendUrgentData(16);
while ((bytesRead = inputStream.read(buffer)) != -1) {
byteArrayOutputStream.write(buffer, 0, bytesRead);
response += byteArrayOutputStream.toString("UTF-8");
}
} catch (UnknownHostException e) {
// TODO Auto-generated catch block
e.printStackTrace();
response = "UnknownHostException: " + e.toString();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
response = "IOException: " + e.toString();
} finally {
if (socket != null) {
try {
socket.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
return null;
}
/* #Override
protected void onProgressUpdate(String... values) {
super.onProgressUpdate(values);
textResponse.setText(values[0]);
Toast.makeText(MainActivity.this,"Server:"+values[0], Toast.LENGTH_LONG).show();
Log.w("MSG","Updating with msg");
}*/
#Override
protected void onPostExecute(Void result) {
textResponse.setText(response);
super.onPostExecute(result);
}
}
public class MainActivity extends Activity {
Button buttonSend;
TextView textViewSocket;
#Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
buttonSend = (Button) findViewById(R.id.buttonSend);
textViewSocket = (TextView) findViewById(R.id.textViewSocket);
buttonSend.setOnClickListener(new View.OnClickListener() {
#Override
public void onClick(View v) {
Client myClient = new Client("192.168.1.25",80,textViewSocket);
myClient.execute();
}
});
}
}
As you can see, I put a long delay in order to get correct and significant answer from the esp8266 but it didn't work :(busy response when trying to close and configure the server each time I send data
So, can someone help me with it ! I'm really stuck :(

Server doesn't seem to receive Client message ANDROID

I am working on a chat client application and I have made a server. I managed to make the client connect to the server, but then when I send a message to the server, there's no reaction from the server.
Here is the part of the code of my server that is not working
class ClientConnect implements Runnable {
private DataInputStream in = null;
private DataOutputStream out = null;
Socket client;
ClientConnect(Socket client) {
try {
this.client = client;
/* obtain an input stream to this client ... */
in = new DataInputStream (client.getInputStream());
/* ... and an output stream to the same client */
setOut(new DataOutputStream (client.getOutputStream()));
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public void run() {
String msg, response;
ChatServerProtocol protocol = new ChatServerProtocol(this);
try {
while (true) {
if (in.available() > 0){
msg = in.readUTF();
response = protocol.process(msg);
getOut().writeBytes("SERVER: " + response);
}
}
} catch (IOException e) {
System.err.println(e);
} finally {
// The connection is closed for one reason or another
try {
client.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
public void sendMsg(String msg) {
try {
getOut().writeBytes(msg);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public DataOutputStream getOut() {
return out;
}
public void setOut(DataOutputStream out) {
this.out = out;
}
}
And here is the client :
#Override
public void onClick(View v) {
// TODO Auto-generated method stub
String response = null;
EditText nicknameField = (EditText)findViewById(R.id.nicknameField);
EditText passwordField = (EditText)findViewById(R.id.passwordField);
nickname = nicknameField.getText().toString();
password = passwordField.getText().toString();
switch(v.getId()){
case R.id.signin:
new SendMessage(this).execute("SIGNUP " + nickname + " " + password );
break;
case R.id.signup:
new SendMessage(this).execute("SIGNUP " + nickname + " " + password );
break;
}
}
private String onPostExecuteSendMessage() {
return null;
}
public void showMessage(String response) {
Builder builder = new AlertDialog.Builder(this);
builder.setMessage(response);
AlertDialog dialog = builder.create();
dialog.show();
}
public void getClientSocket(Socket client) {
this.client = client;
try {
out = new DataOutputStream (client.getOutputStream());
in = new DataInputStream (client.getInputStream());
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public DataOutputStream getOut() {
// TODO Auto-generated method stub
return this.out;
}
public DataInputStream getIn() {
// TODO Auto-generated method stub
return this.in;
}
public void goMenuChat() {
// TODO Auto-generated method stub
Intent intent = new Intent(this, MenuChatActivity.class);
startActivity(intent);
}
}
Also I used an Asynctask to send message from the client :
package client.chatclient;
import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.lang.ref.WeakReference;
import android.os.AsyncTask;
public class SendMessage extends AsyncTask<String, String, String> {
private static final String msg_OK = "OK";
private static final String msg_NICK_IN_USE = "NICK IN USE";
private static final String msg_UNKNOWN_CMD = "UNKNOWN CMD";
private static final String msg_INVALID = "INVALID COMMAND";
private static final String msg_SEND_FAILED = "FAILED TO SEND";
private static final String msg_INCORRECT_IDS = "INCORRECT IDS";
private static final String msg_DISCONNECT = "DISCONNECT";
private WeakReference<MainActivity> activity;
private String message;
private String response = "";
private DataOutputStream out;
private DataInputStream in;
public SendMessage(MainActivity act){
super();
activity = new WeakReference<MainActivity>(act);
}
protected String doInBackground(String... message) {
this.message = message[0];
this.out = activity.get().getOut();
this.in = activity.get().getIn();
try {
out.writeBytes(this.message);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
response = convertStreamToString(this.in);
return response;
}
protected void onPostExecute(String response) {
if ((response == msg_INCORRECT_IDS) || (response == msg_NICK_IN_USE)){
activity.get().showMessage(response);
}
else if (response == msg_OK){
activity.get().goMenuChat();
}
}
private static String convertStreamToString(DataInputStream in) {
/*
* To convert the InputStream to String we use the
* BufferedReader.readLine() method. We iterate until the BufferedReader
* return null which means there's no more data to read. Each line will
* appended to a StringBuilder and returned as String.
*/
BufferedReader reader = new BufferedReader(new InputStreamReader(in));
StringBuilder sb = new StringBuilder();
String line = null;
try {
while ((line = reader.readLine()) != null) {
sb.append(line + "\n");
}
} catch (IOException e) {
e.printStackTrace();
}
return sb.toString();
}
}
I send my message from the client by clicking on a button then it goes to the SendMessage class, and send the message to the server and normally the server should receive my message in the loop "while (true)..." and sends back a response according to the protocol that I've implemented.
I really don't know what is wrong. If you know how to solve this issue or have some solutions, please tell me ! If you want more details, ask me ! :)
Thank you very much !
EDIT:
I instanciated my ClientConnect here
public class ChatServer {
private static int port = 8080;
public static void main (String[] args) throws IOException {
ServerSocket server = new ServerSocket(port); /* start listening on the port */
System.out.println( "Listening on "+ server );
Socket client = null;
while(true) {
try {
client = server.accept();
System.out.println( "Connection from " + client );
/* start a new thread to handle this client */
Thread t = new Thread(new ClientConnect(client));
t.start();
} catch (IOException e) {
System.err.println("Accept failed.");
System.err.println(e);
System.exit(1);
server.close();
}
}
}
}
EDIT: I found where the problem is. I put some log() statements as you said
log.d(null,"beforeconvert")
try {
log.d(null,"convert")
while ((line = reader.readLine()) != null) {
sb.append(line + "\n");
}
} catch (IOException e) {
log.d(null,"errorconvert")
e.printStackTrace();
}
After that in logcat, it just shows "beforeconvert". I don't really know what the problem is ? while ((line = reader.readLine()) != null) is surely the problem. When I use the debugger step by step in eclipse, it stops at this line and doesn't even go inside the loop.
EDIT : I REALLY don't know why, but when I quit the emulator when running my app, it shows everything.
Listening on ServerSocket[addr=0.0.0.0/0.0.0.0,localport=8080]
Connection from Socket[addr=/127.0.0.1,port=56646,localport=8080]
client connected
msg received
error !
SIGNUP Nickname Password
SIGNUP Nickname Password
msg converted
OK
java.net.SocketException: Connection reset
at java.net.SocketInputStream.read(Unknown Source)
at java.net.SocketInputStream.read(Unknown Source)
at java.io.DataInputStream.read(Unknown Source)
at sun.nio.cs.StreamDecoder.readBytes(Unknown Source)
at sun.nio.cs.StreamDecoder.implRead(Unknown Source)
at sun.nio.cs.StreamDecoder.read(Unknown Source)
at java.io.InputStreamReader.read(Unknown Source)
at java.io.BufferedReader.fill(Unknown Source)
at java.io.BufferedReader.readLine(Unknown Source)
at java.io.BufferedReader.readLine(Unknown Source)
at server.ClientConnect.convertStreamToString(ChatServer.java:357)
at server.ClientConnect.run(ChatServer.java:304)
at java.lang.Thread.run(Unknown Source)
java.net.SocketException: Connection reset by peer: socket write error

When you are writing data to output stream in the end you need to flush
this.out.flush();
I think this is why the data is not sent and received
Hope that helps.
Edit:
Let me try to explain in general idea..
When you are opening a socket you have a connection to another machince.
So the
in.available();
and
socket.accpet();
Should work.. once you are writing into outputstream you must flush in order to see the data(or close, i think it flushes before it get closed).
Anyway i attach a link to an example.. You should try this one, Or look at parts you have problem with..
http://examples.javacodegeeks.com/android/core/socket-core/android-socket-example/

Android Bluetooth Client Server Connection

I want to created simple Android bluetooth Client-Server program
Server Code:
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
tv1=(TextView)findViewById(R.id.textView1);
tv2=(TextView)findViewById(R.id.textView2);
mBluetoothAdapter=BluetoothAdapter.getDefaultAdapter();
try {
mBluetoothServerSocket=mBluetoothAdapter.listenUsingRfcommWithServiceRecord(name,uUID);
mBluetoothAdapter.cancelDiscovery();
mBluetoothSocket=mBluetoothServerSocket.accept();
mInputStream=mBluetoothSocket.getInputStream();
//if(mInputStream.available()>0){
mBufferedReader=new BufferedReader(new InputStreamReader(mInputStream));
data = mBufferedReader.readLine();
tv1.setText(data);
//}
if(mInputStream.available()>0){
data=mBufferedReader.readLine();
tv2.setText(data);
x++;
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
Client Code:
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
lb=(Button)findViewById(R.id.button1);
btAdapter = BluetoothAdapter.getDefaultAdapter();
BluetoothDevice device = btAdapter.getRemoteDevice(addressHTC);
try {
btSocket = device.createRfcommSocketToServiceRecord(MY_UUID);
btAdapter.cancelDiscovery();
btSocket.connect();
String message = "Hello.............. from....... Android......\n";
outStream = btSocket.getOutputStream();
byte[] msgBuffer = message.getBytes();
outStream.write(msgBuffer);
}
catch(IOException e){
e.printStackTrace();
}
lb.setOnClickListener(new View.OnClickListener() {
#Override
public void onClick(View v) {
// TODO Auto-generated method stub
String m1="msg 2";
byte[] msgBuffer = m1.getBytes();
try {
outStream.write(msgBuffer);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
}
This application work in one side mode, just Send message to server and show received buffer, But i need to Send back some messages from server to client continuously.
How to do it?
if you have any idea. please share it.

This is works for me for contineously reading. Try it.
try {
BufferedReader Reader = new BufferedReader(
new InputStreamReader(mmSocket.getInputStream()));
while(true)
{
String receivedMsg;
while((receivedMsg = Reader.readLine()) != null)
{
// what you do with your message
}
}
} catch (Exception ex) {
System.out.println(ex);
}

you should have a different thread for listening which will send the message to the activity, this thread can be also the thread sending messages.
that way your the UI wont get stuck and you could receive messages continuously.
an example of such thread:
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import android.app.Activity;
import android.bluetooth.BluetoothSocket;
import android.content.Intent;
import android.util.Log;
public class MessageManager extends Thread {
private static final String TAG = "MessageListener thread";
private BluetoothSocket btConnectedSocket;
private InputStream inStream;
private OutputStream outStream;
private Activity parent;
private boolean run = true;
public MessageManager(BluetoothSocket btConnectedSocket, Activity parent) throws IOException {
this.btConnectedSocket = btConnectedSocket;
this.parent = parent;
inStream = btConnectedSocket.getInputStream();
outStream = btConnectedSocket.getOutputStream();
}
/* this method will listen continuously to messages received through the BT socket until you call cancel
public void run() {
byte[] buffer = new byte[1024];
int bytes;
while (run) {
try {
bytes = inStream.read(buffer);
}
catch(IOException ex) {
Log.e(TAG, "error while reading from bt socket");
}
parent.doStuffWithTheMessage(buffer); // pay attention: its in bytes. u need to convert it to a string
}
}
/* Call this from the main activity to send data to the remote device */
public void write(byte[] bytes) throws IOException{
outStream.write(bytes);
}
/* Call this from the main activity to shutdown the connection */
public void cancel() {
run = false;
try {
btConnectedSocket.close();
} catch (IOException e) { }
}
}

How recognize different URL requests to perform different actions using Android

I am trying to implement code that can recognize different URL requests and perform different actions upon each request, for example, take picture by accessing http://192.168.0.120/pic , and send email by accessing via http://192.168.0.120/email
I already built the code for taking picture and sending email but not sure how to assign them to different URL requests?
I found one code that can run a web server to recognize only one IP address and i want to to modified it to recognize multiple IP addresses and perform different actions upon each request:
The Code:
import java.io.IOException;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.LinkedList;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
public class Server extends Thread {
private ServerSocket listener = null;
private static Handler mHandler;
private boolean running = true;
public static LinkedList<Socket> clientList = new LinkedList<Socket>();
public Server(String ip, int port, Handler handler) throws IOException {
super();
mHandler = handler;
InetAddress ipadr = InetAddress.getByName(ip);
listener = new ServerSocket(port,0,ipadr);
}
private static void send(String s) {
Message msg = new Message();
Bundle b = new Bundle();
b.putString("msg", s);
msg.setData(b);
mHandler.sendMessage(msg);
}
#Override
public void run() {
while( running ) {
try {
Socket client = listener.accept();
new ServerHandler(client).start();
LockStatus.getInstance().setMyVar(true);
clientList.add(client);
} catch (IOException e) {
}
}
}
public void stopServer() {
running = false;
LockStatus.getInstance().setMyVar(false);
try {
listener.close();
} catch (IOException e) {
}
}
Thanks a lot

Here is the modification of the code, but still cannot recognize the IP address:
public void run() {
try {
serverSocket = new ServerSocket(SERVERPORT);
while (running) {
// LISTEN FOR INCOMING CLIENTS
Socket client = serverSocket.accept();
try {
BufferedReader in = new BufferedReader(
new InputStreamReader(client.getInputStream()));
String line = null;
String IP = "192.168.0.111";
line = in.readLine();
if (line.equals(IP)) {
new ServerHandler(client).start();
LockStatus.getInstance().setMyVar(true);
Log.i(TAG, "IP Receive=" + line);
// Toast.makeText(getContext(), "Matches",
// Toast.LENGTH_SHORT).show();
} else {
Log.i(TAG, " IP not received :=" + line);
// Toast.makeText(getApplicationContext(), line +" != "+
// IP, Toast.LENGTH_SHORT).show();
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
} catch (IOException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
}

Fragmented Image byte array over socket

Im trying to send an image as a byte array over a socket to a client so it can view the image, and all goes well except when viewing the image its fragmented, i can view the top 10th of the image but the rest of it is grey and black pixels and i cant figure out why
heres a piece of my server code:
public synchronized void nextFrame(VideoFrame frame) {
// This method is called when a new frame is ready.
// Don't forget to recycle it when done dealing with the frame.
// draw the new frame onto the JLabel
go = true;
pic = frame.getBytes();
go = false;
label.getGraphics().drawImage(frame.getBufferedImage(), 0, 0, width, height, null);
frame.recycle();
}
}
class server extends Thread{
int port;
ServerSocket socket;
Socket temps = null;
boolean go = true;
server(int p){
port = p;
start();
}
public void run(){
while(go == true){
try {
socket = new ServerSocket(port, 10);
socket.setSoTimeout(10000);
temps = socket.accept();
new connect(temps);
port += 1;
} catch (IOException e) {
if(e.getMessage().toString().equalsIgnoreCase("Accept timed out")){
go = false;
}else{
e.printStackTrace();
}
break;
}
}
try {
socket.close();
System.out.println("Closing socket server(no more connections will be created)");
} catch (IOException e) {
e.printStackTrace();
}
}
}
class connect extends Thread{
Socket connection;
ObjectOutputStream out;
int port;
String host;
GetInput in;
connect(Socket s){
try {
connection = s;
out = new ObjectOutputStream(connection.getOutputStream());
host = connection.getInetAddress().getHostName();
port = connection.getPort();
System.out.println("Connected to " + host + ":" + port);
in = new GetInput(connection);
start();
} catch (IOException e) {
e.printStackTrace();
}
}
public void run(){
try {
out.writeInt(Main.pic.length);
} catch (IOException e1) {
e1.printStackTrace();
}
while(in.isAlive()){
if(Main.go){
try {
out.write(Main.pic);
} catch (IOException e) {
e.getMessage().toString();
}
}
}
try {
out.close();
connection.close();
System.out.println("Closing " + host + ":" + port);
} catch (IOException e) {
e.printStackTrace();
}
}
}
class GetInput extends Thread{
ObjectInputStream in;
GetInput(Socket s){
try {
in = new ObjectInputStream(s.getInputStream());
} catch (IOException e) {
e.printStackTrace();
}
start();
}
public void run(){
try{
boolean go = in.readBoolean();
int a = (go?1:0);
System.out.println(a);
} catch (IOException e) {
e.getMessage().toString();
}
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
i know the frame grabber is grabbing the image right because im also displaying the image on the server and it looks fine, so that means the byte arrays not getting sent over the sockets correctly, but why?
EDIT: heres my client code, its an android app
package org.smiley.doom;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
import android.app.Activity;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.ImageView;
import android.widget.TextView;
public class ClientActivity extends Activity implements View.OnClickListener{
Socket s;
InetAddress inet;
ObjectOutputStream out;
ObjectInputStream in;
TextView log;
ImageView im;
Button send;
EditText tip;
int rport;
String ip;
#Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
tip = (EditText) findViewById(R.id.etIP);
send = (Button) findViewById(R.id.bSEND);
im = (ImageView) findViewById(R.id.ivPIC);
log = (TextView) findViewById(R.id.tvLog);
s = null;
in = null;
out = null;
send.setOnClickListener(this);
}
#Override
public void onClick(View arg0) {
switch(arg0.getId()){
case R.id.bSEND:
final int len;
try {
inet = InetAddress.getByName("192.168.0.2");
s = new Socket(inet, 4321);
in = new ObjectInputStream(s.getInputStream());
out = new ObjectOutputStream(s.getOutputStream());
log.setText("Client opened");
len = in.readInt();
new Thread(new Runnable(){
#Override
public void run() {
byte[] b = new byte[len];
try {
in.read(b);
log.setText(""+s.getReceiveBufferSize());
} catch (IOException e1) {
e1.printStackTrace();
}
final byte[] l = b;
im.post(new Runnable(){
#Override
public void run() {
Bitmap bmp = BitmapFactory.decodeByteArray(l, 0, l.length);
im.setImageBitmap(bmp);
}
});
try {
out.writeBoolean(true);
out.close();
in.close();
s.close();
//log.setText("Client closed");
} catch (IOException e) {
e.printStackTrace();
}
}
}).start();;
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
break;
}
}
}

TCP only delivers as many bytes to the application as currently available. Since the underlying network layer (IP) is packet based, your stream is getting chunked into parts during transmission. Network stack on the receiving side gets these chunks (packets) off the network card and buffers them until an application reads from given socket, at which point you get min of your buffer size and what's piled up in the OS per-socket buffer.
Because TCP connection represents a stream, the OS doesn't know anything about your application messages, so it's your responsibility to reassemble everything back together.
You have to read from the socket in a loop until you know you have all your data. The easiest way to know that is to tell the client upfront how many bytes you are going to send.

Chances are your data segment (image) is much larger than your buffer.
Somehow, you have to find a way to buffer the output so you can flush it before you overflow your write buffer.

Nikolai Fetissov's answer helped me solve the issue. Here's how I got it to work:
Send a JSON (or any other format) containing the expected message
size and message type from sender to receiver. Make sure this is
short and sweet.
Immediately send your data. It could be an image/audio/video or anything.
Bonus: This will work for Android Bluetooth/Wifi Sockets too.
Code snippet to go with:
byte[] fileBuffer = null;
int bytes = 0, expectedFileSize = 0, messageType = Constants.TYPE_IMAGE;
boolean isProcessing = false;
while (isReading) {
try {
if (isProcessing) {
// Fragment arrived
byte[] buffer = new byte[1024];
int currentSize = mmInStream.read(buffer);
// Keep appending to the fileBuffer
System.arraycopy(buffer, 0, fileBuffer, bytes, currentSize);
bytes += currentSize;
if (bytes == expectedFileSize) {
// Your message is ready. Send it!
sendIt(fileBuffer, messageType);
isProcessing = false;
bytes = 0;
}
} else {
byte[] buffer = new byte[1024];
bytes = mmInStream.read(buffer);
try {
// Message is a JSON. Next set of messages will be audio or image.
JSONObject json = new JSONObject(new String(buffer, 0, bytes));
expectedFileSize = json.getInt(Constants.MESSAGE_SIZE);
messageType = json.getInt(Constants.MESSAGE_TYPE);
fileBuffer = new byte[expectedFileSize];
isProcessing = true;
bytes = 0;
} catch (JSONException e) {
// This is a normal message. Send it without processing.
sendIt(buffer, Constants.TYPE_TEXT);
isProcessing = false;
bytes = 0;
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
Edits to the code to optimize it further are welcome! Hope this helps.