CMSC628: Introduction to Mobile Computing
Nilanjan Banerjee
University of Maryland
Baltimore County, MD
Mobile Systems Programming (Acknowledgment to Deepa Shinde and Cindy Atheron
1
Socket Programming
TCP and UDP
2
Socket programming
Goal: learn how to build client/server application that
communicate using sockets
Socket API
• introduced in BSD4.1 UNIX,
1981
• explicitly created, used,
released by apps
• client/server paradigm
• two types of transport service
via socket API:
– unreliable datagram
– reliable, byte streamoriented
socket
a host-local,
application-created,
OS-controlled interface
(a “door”) into which
application process can
both send and
receive messages to/from
another application
process
3
TCP
4
Socket-programming using TCP
Socket: a door between application process and endend-transport protocol (UCP or TCP)
TCP service: reliable transfer of bytes from one
process to another
controlled by
application
developer
controlled by
operating
system
process
process
socket
TCP with
buffers,
variables
host or
server
internet
socket
TCP with
buffers,
variables
controlled by
application
developer
controlled by
operating
system
host or
server
2: Application Layer
5
Socket programming with TCP
Client must contact server
• server process must first be
running
• server must have created
socket (door) that welcomes
client’s contact
Client contacts server by:
• creating client-local TCP
socket
• specifying IP address, port
number of server process
• When client creates socket:
client TCP establishes
connection to server TCP
• When contacted by client,
server TCP creates new
socket for server process to
communicate with client
– allows server to talk with
multiple clients
– source port numbers used
to distinguish clients
application viewpoint
TCP provides reliable, in-order
transfer of bytes (“pipe”)
between client and server
2: Application Layer
6
Stream jargon
• A stream is a sequence of
characters that flow into
or out of a process.
• An input stream is
attached to some input
source for the process, eg,
keyboard or socket.
• An output stream is
attached to an output
source, eg, monitor or
socket.
7
Socket programming with TCP
2) server reads line from socket
3) server converts line to
uppercase, sends back to
client
4) client reads, prints modified
line from socket
(inFromServer stream)
Client
P ro ce ss
process
in p u t
s tre a m
o u tp u t
s tre a m
i n F ro m S e rv e r
1) client reads line from standard
input (inFromUser stream) ,
sends to server via socket
(outToServer stream)
o u tT o S e rv e r
Example client-server app:
m o n ito r
i n F ro m U s e r
k e y b o a rd
in p u t
s tre a m
client
TCP
c lie n tS o c k e t
socket
to n e tw o rk
TCP
socket
fro m n e tw o rk
8
Client/server socket interaction: TCP
Server (running on hostid)
Client
create socket,
port=x, for
incoming request:
welcomeSocket =
ServerSocket()
TCP
wait for incoming
connection request connection
connectionSocket =
welcomeSocket.accept()
read request from
connectionSocket
write reply to
connectionSocket
close
connectionSocket
setup
create socket,
connect to hostid, port=x
clientSocket =
Socket()
send request using
clientSocket
read reply from
clientSocket
close
clientSocket
9
Example: Java client (TCP)
import java.io.*;
import java.net.*;
class TCPClient {
public static void main(String argv[]) throws Exception
{
String sentence;
String modifiedSentence;
Create
input stream
Create
client socket,
connect to server
Create
output stream
attached to socket
BufferedReader inFromUser =
new BufferedReader(new InputStreamReader(System.in));
Socket clientSocket = new Socket("hostname", 6789);
DataOutputStream outToServer =
new DataOutputStream(clientSocket.getOutputStream());
10
Example: Java client (TCP), cont.
Create
input stream
attached to socket
BufferedReader inFromServer =
new BufferedReader(new
InputStreamReader(clientSocket.getInputStream()));
sentence = inFromUser.readLine();
Send line
to server
outToServer.writeBytes(sentence + '\n');
Read line
from server
modifiedSentence = inFromServer.readLine();
System.out.println("FROM SERVER: " + modifiedSentence);
clientSocket.close();
}
}
11
Example: Java server (TCP)
import java.io.*;
import java.net.*;
class TCPServer {
Create
welcoming socket
at port 6789
Wait, on welcoming
socket for contact
by client
Create input
stream, attached
to socket
public static void main(String argv[]) throws Exception
{
String clientSentence;
String capitalizedSentence;
ServerSocket welcomeSocket = new ServerSocket(6789);
while(true) {
Socket connectionSocket = welcomeSocket.accept();
BufferedReader inFromClient =
new BufferedReader(new
InputStreamReader(connectionSocket.getInputStream()));
12
Example: Java server (TCP), cont
Create output
stream, attached
to socket
DataOutputStream outToClient =
new DataOutputStream(connectionSocket.getOutputStream());
Read in line
from socket
clientSentence = inFromClient.readLine();
capitalizedSentence = clientSentence.toUpperCase() + '\n';
Write out line
to socket
outToClient.writeBytes(capitalizedSentence);
}
}
}
End of while loop,
loop back and wait for
another client connection
13
UDP
14
Socket programming with UDP
UDP: no “connection”
between client and server
• no handshaking
• sender explicitly attaches
IP address and port of
destination to each packet
• server must extract IP
address, port of sender
from received packet
application viewpoint
UDP provides unreliable transfer
of groups of bytes (“datagrams”)
between client and server
UDP: transmitted data may
be received out of order,
or lost
15
Client/server socket interaction: UDP
Server (running on hostid)
create socket,
port=x, for
incoming request:
serverSocket =
DatagramSocket()
read request from
serverSocket
write reply to
serverSocket
specifying client
host address,
port number
Client
create socket,
clientSocket =
DatagramSocket()
Create, address (hostid, port=x,
send datagram request
using clientSocket
read reply from
clientSocket
close
clientSocket
16
Example: Java client (UDP)
in p u t
s tre a m
Client
process
m o n ito r
in F ro m Use r
k e y b o a rd
P ro c e s s
Input: receives
packet (TCP
received “byte
stream”)
UDP
packet
re ce ive P a cke t
packet (TCP sent
“byte stream”)
se n d P a ck e t
Output: sends
client
UDP
c lie n tS o c k e t
socket
to n e tw o rk
UDP
packet
UDP
socket
fro m n e tw o rk
17
Example: Java client (UDP)
import java.io.*;
import java.net.*;
Create
input stream
Create
client socket
Translate
hostname to IP
address using DNS
class UDPClient {
public static void main(String args[]) throws Exception
{
BufferedReader inFromUser =
new BufferedReader(new InputStreamReader(System.in));
DatagramSocket clientSocket = new DatagramSocket();
InetAddress IPAddress = InetAddress.getByName("hostname");
byte[] sendData = new byte[1024];
byte[] receiveData = new byte[1024];
String sentence = inFromUser.readLine();
sendData = sentence.getBytes();
18
Example: Java client (UDP), cont.
Create datagram
with data-to-send,
length, IP addr, port
Send datagram
to server
DatagramPacket sendPacket =
new DatagramPacket(sendData, sendData.length, IPAddress, 9876);
clientSocket.send(sendPacket);
DatagramPacket receivePacket =
new DatagramPacket(receiveData, receiveData.length);
Read datagram
from server
clientSocket.receive(receivePacket);
String modifiedSentence =
new String(receivePacket.getData(),0,receivePacket.getLength());
System.out.println("FROM SERVER:" + modifiedSentence);
clientSocket.close();
}
}
19
Example: Java server (UDP)
import java.io.*;
import java.net.*;
Create
datagram socket
at port 9876
class UDPServer {
public static void main(String args[]) throws Exception
{
DatagramSocket serverSocket = new DatagramSocket(9876);
byte[] receiveData = new byte[1024];
byte[] sendData = new byte[1024];
while(true)
{
Create space for
received datagram
Receive
datagram
DatagramPacket receivePacket =
new DatagramPacket(receiveData, receiveData.length);
serverSocket.receive(receivePacket);
20
Example: Java server (UDP), cont
String sentence = new String(receivePacket.getData());
Get IP addr
port #, of
sender
InetAddress IPAddress = receivePacket.getAddress();
int port = receivePacket.getPort();
String capitalizedSentence = sentence.toUpperCase();
sendData = capitalizedSentence.getBytes();
Create datagram
to send to client
Write out
datagram
to socket
}
DatagramPacket sendPacket =
new DatagramPacket(sendData, sendData.length, IPAddress,
port);
serverSocket.send(sendPacket);
}
}
End of while loop,
loop back and wait for
another
datagram
2: Application
Layer
21
Package
org.apache.*
Description
Represents a number of packages that provide fine control and
functions for HTTP communications. You might recognize Apache as the
popular open source Web server.
android.net
Contains additional network access sockets beyond the core java.net.*
classes. This package includes the URI class, which is used frequently in
Android application development beyond traditional networking.
android.net.http
Contains classes for manipulating SSL certificates.
android.net.wifi
Contains classes for managing all aspects of WiFi (802.11 wireless
Ethernet) on the Android platform. Not all devices are equipped with
WiFi capability, particularly as Android makes headway in the "flipphone" strata of cell phones from manufacturers like Motorola and LG.
android.telephony
Contains classes required for managing and sending SMS (text)
messages. Over time, an additional package will likely be introduced to
provide similar functions on non-GSM networks, such as CDMA, or
something like android.t lephony.cdma.
Required Packages
How does the Bluetooth protocol work?
discovery
pairing
Service Discovery
RFComm
Scanning for other BT
Devices --- inquiry scan
Followed by page scan. Take
about 15-20 seconds
Authentication process where
two devices exchange a pin.
Once paired the info is
maintained in service
discovery db
Every server device publishes
a set of service that client
connect to
After pairing the devices
communicate amongst each
other over a RF
communication channel
Android implementation overview?
BluetoothAdapte
r
BluetoothDevice
Access to the local Bluetooth
device and its properties
Access to any Bluetooth
device (usually remote)
BluetoothServerSocket
Socket interface for the
server-end
BluetoothSocket
Socket interface for the
client-end
Bluetooth Permissions
• Permission BLUETOOTH is used ONLY for communication
–
Requesting a connection, accepting a connection, and transferring data
• Permission BLUETOOTH_ADMIN is used for controlling the device
–
Device discovery, changing the settings of the Bluetooth device etc.
<manifest>
<uses permission android:name=“android.permission.BLUETOOTH”>
<uses permission android:name=“android.permission.BLUETOOTH_ADMIN”>
</manifest>
Setting up the Bluetooth Adapter
– Use BluetoothAdapter to get a reference to the Bluetooth device
• If Bluetooth device is not supported the adapter returns a NULL
– Enable Bluetooth device using an Intent and starting a new Activity with
the Bluetooth device
• It does ask the user whether he wants to enable the device
• How do you know that the Bluetooth device is enabled? --- the resultcode in
onActivityResult() callback will be RESULT_OK.
Bluetooth adapter = BluetoothAdapter.getDefaultAdapter();
if(adapter == null)
{
//Device does not support Bluetooth.
}
if(!adapter.isEnabled()) {
Intent enableBT = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
startActivityForResult(enableBT, REQUEST_ENABLE_BT);
}
Discovering devices
– First step is to find devices that you have already paired with: these are
devices you do not need to pair to get connected
– Use a broadcast receiver discover new Bluetooth devices
Set<BluetoothDevice> pairedDevices = adapter.getBondedDevices();
if (pairedDevices.size() > 0) {
for(BluetoothDevice device: pairedDevices) {
//get access to the devices name through device.getName();
//get access to the devices MAC address through device.getAddress();
}
}
//discovering devices
adapter.startDiscover();
private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
public void onReceive(Context context, Intent intent)
{
String action = intent.getAction();
if(BluetoothDevice.ACTION_FOUND.equals(action)) {
BluetoothDevice device =
intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
//get the name of the device through device.getName();
//get the MAC address of the device through device.getAddress();
}
}
IntentFilter filter = new IntentFilter(Bluetooth.ACTION_FOUND);
registerReceiver(mReceiver, filte); //register for broadcast receiver when a BT device
is found.
Enabling Discovery
– Why do you need to set a device’s Bluetooth to Discoverable
• If you are a server and you want client devices to connect to you
• If you want other devices to see you in order to pair with you
– You set it up using an Intent
• A parameter that you can set up is the time that you want the device to be discoverable
• Default = 120 seconds, 0  forever, max = 3600, < 0 or > 3600 – default is taken.
Intent discoverable = new Intent(BluetoothAdapter.BLUETOOTH_ACTION_DISCOVERABLE);
Discoverable.putExtras(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION, 300);
startActivity(discoverable);
Connecting to a device (server-side)
– Just like a TCP socket called BluetoothServerSocket
– You wait on an accept() (blocking call) till you receive an incoming
connection request
– accept() is blocking so it should happen in a separate thread from the
UI thread
Name of the
service
Unique ID for
the service
public class AcceptConnection extends Thread{
private final BluetoothServerSocket soc;
public AcceptConnection() {
try {
soc = adapter.listenUsingRfcommWithServiceRecord(NAME, UDID);
} catch(IOException e){}
}
public void run() {
BluetoothSocket socket = null;
while(true) {
try {
soc.accept();
} catch(IOException e) { break; }
if(soc != null) {
//spawn another thread to manage the connection
}
}
}
}
Connecting to a device (client-end)
– Connect() is a blocking call so needs to happen in a thread separate
from the UI thread
– From the remote device, create a Rfcomm channel for data transfer.
public class ClientThread extends Thread {
BluetoothSocket temp = null;
public ClientThread(Bluetooth device)
{
try {
temp = device.createRfcommSocketToServiceRecord(UDID);
}catch(Exception e) { }
}
public void run() {
adapter.cancelDiscover();
try
{
temp.connect();
} catch(Exception e) { }
//manage the connection
}
}
Data transfer using the server/client socket
– Attach an InputStream and an OutputStream to the the socket
– Use read(byte[]) and write(byte[]) to read and write --- both are
blocking calls
public class ClientThread extends Thread {
BluetoothSocket temp = null;
public ClientThread(Bluetooth device)
{
try {
temp = device.createRfcommSocketToServiceRecord(UDID);
}catch(Exception e) { }
}
public void run() {
byte[] buffer = new byte[1024];
int numbytes;
adapter.cancelDiscover();
try
{
numbytes = temp.read(buffer);
//do whatever you want with the bytes
} catch(Exception e) { }
//manage the connection
}
}