Develop Reference

Android Socket: Read Continuous Data

I am trying to read data continuously using the following code:
public class MyClientTask extends AsyncTask<Void, Void, Void> {
String dstAddress;
int dstPort;
String response = "";
MyClientTask(String addr, int port){
dstAddress = addr;
dstPort = port;
}
#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();
while ((bytesRead = inputStream.read(buffer)) != -1){
readInpt = inputStream.toString();
byteArrayOutputStream.write(buffer, 0, bytesRead);
response = byteArrayOutputStream.toString("UTF-8");
}
textResponse.setText(readInpt);
} 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 onPostExecute(Void result) {
textResponse.setText(response);
super.onPostExecute(result);
}
}
But for some reason, it doesn't show me any output in the textbox. any help would be appreciated.

There are at least two issues in your code.
Frist, I'm not sure the method toString() on the inputStream is going to work, because the documentation says it returns a description of the object (which would be different than the string recieved). You might be confusing this with the contents of buffer which might be what you really want.
readInpt = inputStream.toString(); // Probably wrong
Second. You're updating the User Interface from a background thread, inside doInBackground() , which is always forbidden.
textResponse.setText(readInpt); // Forbidden, move somewhere else, e.g. onPostExecute()

try {
socket = new Socket(dstAddress, dstPort);
BufferedReader stdIn = new BufferedReader(new InputStreamReader(socket.getInputStream()));
while (true) {
response = stdIn.readLine();
publishProgress(response);
Log.i("response", response);
}
} 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();
}
catch (Exception e) {
e.printStackTrace();
}
You cannot print it on text field because the socket will listen to the server socket.If server socket does not send any response it will listen to the socket continuously until the response is received.

Transfer data between 2 android devices

I'd like write an app to transfer data between 2 android devices on the same wifi network, like as there is a share folder.
How can i do this?
Thanks
EDIT (My solution):
My Server wait for request
private boolean startServer() {
try {
server = new ServerSocket(port);
} catch (IOException ex) {
ex.printStackTrace();
return false;
}
return true;
}
public void runServer() {
while (this.go) {
try {
Log.d("BurgerClub", "Server in attesa di richieste");
Socket s1 = server.accept();
OutputStream s1out = s1.getOutputStream();
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
s1out));
BufferedReader br = new BufferedReader(new FileReader(this.path));
String counter = br.readLine();
counter = counter != null ? counter : "000";
br.close();
bw.write(counter);
bw.close();
s1.close();
} catch (IOException ex) {
ex.printStackTrace();
}
}
}
My Client (Runnable object)
public void run() {
try {
this.openConnection();
// Se il socket è connesso
if( !this.s1.isClosed() ) {
InputStream is = this.s1.getInputStream();
BufferedReader dis = new BufferedReader(new InputStreamReader(is));
line = dis.readLine();
if( !this.previousCounter.equals(line.trim()) ) {
((BurgerClub_MonitorActivity) counterContext).runOnUiThread(new Runnable() {
#Override
public void run() {
TextView edit = (TextView)(((BurgerClub_MonitorActivity) counterContext).findViewById(R.id.textActionCounter));
edit.setText(line);
}
});
this.previousCounter = line.trim();
}
dis.close();
}
} catch (ConnectException connExc) {
connExc.printStackTrace();
} catch (IOException ex) {
ex.printStackTrace();
} catch (Throwable ex) {
ex.printStackTrace();
}

One device needs to serve as a server and the other one will be the client.
The basic flow needs to be something of this sort:
Server device opens a socket and listens on it.
Server device broadcasts the local IP and port it's listening on.
Client device receives broadcast and initiates a connection.
Perform data transfer.

Read about NFC (Near field communication)
http://developer.android.com/guide/topics/connectivity/nfc/index.html

How to retry "try-catch" in a finite number and delay it?

I use this code to transfer data between two device.
public void run() {
try {
Socket s = new Socket(myIpAddress, SERVERPORT);
// outgoing stream redirect to socket
OutputStream out = s.getOutputStream();
PrintWriter output = new PrintWriter(out);
output.println("DLS");
BufferedReader input = new BufferedReader(new InputStreamReader(
s.getInputStream()));
// read line(s)
String st = input.readLine();
// . . .
// Close connection
s.close();
} catch (UnknownHostException e) {
run();
e.printStackTrace();
} catch (IOException e) {
run();
e.printStackTrace();
}
}
My problem is i have to start the server first and after that, i can start the client for a successful connection.
In the
public void run()
I put run() to the UnknownHostException and to the IOException.
It works fine in an other code but here i get the StackOverFlowError.
How can i make it to RE-try in a finite number and only try every X second?
I tried this way because the run() and Thread.sleep(5000); cried for the unhandled exceptions. When i start the service, the app is froze.
public void run() throws UnknownHostException, IOException {
Socket s = new Socket(myIpAddress, SERVERPORT);
// outgoing stream redirect to socket
OutputStream out = s.getOutputStream();
PrintWriter output = new PrintWriter(out);
output.println("DLS");
s.close();
}
#Override
public void onCreate() {
for (int i = 0; i < 10; i++) {
try {
run();
break; // no exception: break out of the loop.
}
catch (IOException e) {
try {
Thread.sleep(5000);
} catch (InterruptedException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
}
}

Before you call run() in catch, you can do-
Thread.sleep(1000); // 1000 milli second = 1 second
This will make the thread sleep for a second before it calls run again. Also, you should not try forever as this leads to a bad recursive call and there will not be enough space in stack left to carry on with any more code execution including printing the error. Maybe you should try a maximum of 5 to 10 times with an interval of 3 seconds and give up.
Stack overflow error happens when there's no virtual memory is left to carry on an execution.
Say you are calling run from create method-
private static final int MAX_TRY = 5;
public void create(){
for(int i = 0; i < MAX_TRY; i++){
if(run()){ // if run call returns true, then get out of the loop
break;
} else {
Thread.sleep(1000); // Wait for a second before next try
}
}
}
public boolean run() {
boolean isSuccessful = false;
try {
Socket s = new Socket(myIpAddress, SERVERPORT);
// outgoing stream redirect to socket
OutputStream out = s.getOutputStream();
PrintWriter output = new PrintWriter(out);
output.println("DLS");
BufferedReader input = new BufferedReader(new InputStreamReader(
s.getInputStream()));
// read line(s)
String st = input.readLine();
// . . .
isSuccessful = true;
} catch (Exception e) {
e.printStackTrace();
} finally {
s.close();
}
return isSuccessful;
}

You're writing a function that recuses on failure with no delays. This is undesirable for a couple of reasons, one of which is that you can blow out the call-stack (as you're seeing).
Generally, i'd recommend pulling out the piece of code that can fail into its own function and have that specifically return success vs. retryable failure vs. other failure (e.g. with a custom "RetryableFailure" subclass of exception). Then you can call that from code that can retry if necessary and after a delay.
E.g.
class RetryableException extends Exception {
public RetryableException(Throwable: underlying) {
...
}
}
public void tryIt() throws RetryableException {
Socket s = null;
try {
s = new Socket(myIpAddress, SERVERPORT);
// outgoing stream redirect to socket
OutputStream out = s.getOutputStream();
PrintWriter output = new PrintWriter(out);
output.println("DLS");
BufferedReader input = new BufferedReader(new InputStreamReader(
s.getInputStream()));
// read line(s)
String st = input.readLine();
// . . .
} catch (UnknownHostException e) {
throw new RetryableException(e);
} catch (IOException e) {
throw new RetryableException(e);
} finally {
if (s != null) {
s.close();
}
}
}
public void run() {
boolean succeeded = false;
while (! succeeded) {
try {
tryIt();
succeeded = true;
} catch (RetryableException e) {
// log
Thread.sleep(1000);
}
}
}
Also note the following:
i've move the socket.close to a finally block
if you're calling this from onCreate (as you said in a comment), you'll probably want to restructure this into a Service rather than blocking the main thread. — http://developer.android.com/reference/android/app/Service.html

You just need a loop (which IMO, is simpler to understand than recursion):
for (int i = 0; i < MAX_ATTEMPTS; i++) {
try {
run();
break; // no exception: break out of the loop.
}
catch (UnknownHostException | IOException e) {
Thread.sleep(DELAY_BETWEEN_ATTEMPTS_IN_MILLIS);
}
}
Of course, you must not catch the exceptions anymore from the run() method itself.

Functioning Socket read no longer works when called in AsyncTask

I'm making an app that sends a string to a server over a socket and then reads the output after the server has processed that data. It worked perfectly when it was my foreground task, but I have since used AsyncTask to show a process dialog while the socket communication runs in the background, and things start breaking after I read the output from the server and then try to close the socket.
private class Progressor extends AsyncTask<String, Void, Void> {
ProgressDialog dialog;
protected void onPreExecute() {
dialog = ProgressDialog.show(ClearTalkInputActivity.this, "Loading..", "Analyzing Text", true, false);
}
protected Void doInBackground(String... strings) {
String language = strings[0].toLowerCase();
String the_text = strings[1];
Socket socket = null;
DataOutputStream dos = null;
DataInputStream dis = null;
try {
socket = new Socket(my_ip, port);
dos = new DataOutputStream(socket.getOutputStream());
dis = new DataInputStream(socket.getInputStream());
dos.writeUTF(language+"****"+the_text);
String in = "";
while (in.indexOf("</content>") < 0) {
in += dis.readUTF();
}
socket.close();
save_str(OUTPUT_KEY, in);
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
finally {
if (socket != null) {
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
if (dos != null) {
try {
dos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (dis != null) {
try {
dis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return null;
}
protected void onPostExecute() {
if (dialog.isShowing())
dialog.dismiss();
startActivity(new Intent (output_intent));
}
}

The recommended way in Android is to use one of the two included HttpClients:
Apache HTTP Client
HttpURLConnection
There is no need to use sockets directly. These clients do a lot to improve your experience.
Here is a blog article by the Android developers, that explain the basics: http://android-developers.blogspot.de/2011/09/androids-http-clients.html

Android TCP client

I'm currently working on a tcp client in Android.
I want to connect my android device to a tcp server on my computer and receive the data once every 2 seconds. The problem is that I'm getting force close on my application because of the while loop that I've implemented in the tcp client.
I've tried writing in different ways the loop that will make the tcp client checking the server socket, but with no success. How can make a loop that will check the server socket without getting the force close?
Here's my code that I'm currently using:
public class Connection implements Runnable {
#Override
public void run() {
try {
sk=new Socket(server,port);
viewsurface.setText("connected");
flag = true;
} catch (UnknownHostException e) {
viewsurface.setText("failed 1 socket");
flag = false;
} catch (IOException e) {
viewsurface.setText("failed 2 socket");
flag = false;
}
while (flag == true){
try {
checkin = sk.getInputStream();
checkint = checkin.available();
if (checkint > 0){
try {
BufferedReader in = new BufferedReader(new InputStreamReader(sk.getInputStream()));
received = in.readLine();
viewsurface.setText(received);
} catch (IOException e) {
viewsurface.setText("failed to receive");
}
}
Thread.sleep(2000);
} catch (IOException e) {
viewsurface.setText("checkin failed");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}

You need to paste the exception that you are getting to cause the force close, before anyone can provide decent help.
But some suggestions that might solve the problem.
Most likely to be the problem, viewText.setText can only be called from the UI thread. There's quite a few ways to handle this. You can use AsyncTask or if you have an Activity reference you can use runOnUIThread and pass in a runnable that calls setText.
Move checkin = sk.getInputStream(); to before the loop. There's no reason to get the strem every cycle through the loop.
Do not create the BufferedReader every cycle through the loop. Move it before the loop
.sleep(2000) does not guarantee exactly 2 seconds.
I'm having some code formatting issues so I apologize.
private class DownloadFilesTask extends AsyncTask<Void, String, Void> {
protected Long doInBackground(Void... nothing) {
try {
sk=new Socket(server,port);
publishProgress("connected");
flag = true;
} catch (UnknownHostException e) {
publishProgress("failed 1 socket");
flag = false;
} catch (IOException e) {
publishProgress("failed 2 socket");
flag = false;
}
while (flag == true){
try {
checkin = sk.getInputStream();
checkint = checkin.available();
if (checkint > 0){
try {
BufferedReader in = new BufferedReader(new InputStreamReader(sk.getInputStream()));
received = in.readLine();
publishProgress(received);
} catch (IOException e) {
publishProgress("failed to receive");
}
}
Thread.sleep(2000);
} catch (IOException e) {
updateProgress(
} catch (InterruptedException e) {
e.printStackTrace();
}
return;
}
protected void onProgressUpdate(String... progress) {
viewsurface.setText(progress[0]);
}
protected void onPostExecute(Void result) {
//nothing
}
}