download report

Transcript class7-intro-to-tcp-ip-and-socket-programming

Introduction to Socket Programming in
Jules White
Bradley Dept. of Electrical and
Computer Engineering
Virginia Tech
[email protected]
What is a Socket?
• A socket is a software endpoint that can plug into or be plugged into
to create a bi-directional communication link between software
• A socket is a common interface for performing network
• Underneath the hood, Android’s HTTP client library is using sockets
to send and receive data
Java Sockets
• In Java, a ServerSocket can receive new connections from a client
• A client connects to a remote ServerSocket through a standard
Socket instance
• When the server receives the connection, it talks to the client using a
standard socket
InputStreams in Java
• An InputStream is a stream of incoming byte data
• An InputStream can be obtained from a Socket by using the
getInputStream() method
• In order to read from a stream, you must create a byte buffer to read
in data
• Each call to read on an InputStream fills your buffer with data and
returns the number of bytes read
InputStream in = somesocket.getInputStream();
byte[] buffer = new byte[1024];
int bytesread = 0;
while( (bytesread =,0,buffer.length)) != -1){
//the buffer has been filled, do something with the data
OutputStreams in Java
• An OutputStream is a stream of outgoing byte data
• An OutputStream can be obtained from a Socket by using the
getOutputStream() method
• You can write data to a stream by passing in a byte buffer of data
• You should use the flush() method if you want to make sure that the
data you have written has been output to disk or sent to the other
end of the socket
OutputStream out = somesocket.getOutputStream();
out.write(“Hello Socket”.getBytes());
byte[] buffer = new byte[1024];
//fill the buffer
A Simple Socket-based Server
• Example:
public class ExampleServerSocket{
public void start() throws Exception {
//Create a ServerSocket on port 9090
ServerSocket serversock = new ServerSocket(9090);
Socket client = serversock.accept();
OutputStream out = client.getOutputStream();
InputStream in = client.getInputStream();
//read and write some data from the streams
A Simple Socket-based Client
• Example:
public class ExampleSocketClient{
public void start() throws Exception {
Socket server = Socket(
“”, //the host or IP address to connect to
9090 //the port to connect to on that host
OutputStream out = server.getOutputStream();
InputStream in = server.getInputStream();
out.flush(); //VERY IMPORTANT
// read some stuff….
Threading in Android
• Socket and streaming network operations may take a significant
amount of time
• You cannot block the GUI thread for too long in Android
• In order to connect as a client or receive connections, you must
spawn threads to handle the communication
• To spawn a Thread in Java, create a class that implements runnable
and construct a new Thread object with it
public class LongRunningWork implements Runnable {
public void run(){
//do long running stuff here
public void threadMe(){
Thread t = new Thread(this);
What Should You Thread?
• For the client, you need to thread the instantiation of the Socket and
all read/write operations to it when it is connected
• For the server, you need to have multiple threads
• Some thread needs to call accept()
• Some thread needs to manage reading/writing data for each client
after a socket is returned from accept
• The threading architecture is very important
• Possible threading approaches:
• Thread per connection
• Eager spawning / thread pools
• Half-sync / Half-async
• Leader / Followers
Synchronizing the GUI Thread with Others
• Once approach that we have learned is to use a Handler to
coordinate the exchange of work between the GUI and other threads
• Another approach is to use the Android AsyncTask class
• Android automatically manages the creation of Threads for
• An AsyncTask has three key methods that each run in a different
thread context:
• doInBackground() – runs in a NON-GUI thread
• onProgressUpdate() – runs in the GUI thread
• onPostExecute() – runs in the GUI thread
• You create a subclass of AsyncTask and Android automatically runs
each of your implementations of these methods in the correct thread
The AsyncTask Template Parameters
• The types specified in the template parameters correspond to the parameter type of the doInBackground
method, the type for the parameter to onProgressUpdate, and the type that is returned by doInBackground
public class HttpTask extends AsyncTask<String, Integer, Long> {
protected Long doInBackground(String... params) {
//this runs in a background thread from the pool
return new Long(0);
protected void onProgressUpdate(Integer... progress) {
//this runs in the UI thread
//this is where you notify any callbacks that require incremental progress
protected void onPostExecute(Long result) {
//this runs in the UI thread
//this is where you would invoke your callback to the entity that created the request
AsyncTask Example
public class HttpTask extends AsyncTask<String, Float, String> {
protected Long doInBackground(String... params) {
Socket socket = new Socket(some_host,some_port);
InputStream in = socket.getInputStream();
byte[] buff = new byte[1024];
float expectedsize = 12341234;
int read = 0;
float totalread = 0;
while( (,0,buff.length)) != -1){
totalread += read;
return “It worked!”;
protected void onProgressUpdate(Float... progress) {
//this runs in the UI thread
//this is where you notify any callbacks that require incremental progress
someProgressBar_.setValue(progress * 100);
protected void onPostExecute(String result) {
//this runs in the UI thread
//this is where you would invoke your callback to the entity that created the request