Overview of Networking

Over the next couple days we are going to look at how to write networking Apps, both in Android and on the iPhone.
A group of interconnected computers is a network.
The main network you are probably familiar with, the internet, is based on a layered architecture called the TCP/IP stack.
It consists of the following layers:
- Link Layer -- this layer is concerned with how the medium through which bits are actually sent is manipulated to send 1 and 0s (physical layer) as well as concerned with protocols to communicate between hosts in a local area network. For example, how signalling is done on a wire, radio, etc; you might use ARP and DHCP to map between IP and physical address of a host or to assign it.
- Internet Layer -- consists of the internet protocol (IP) used to send packets between hosts on the network.
- Transport Layer -- consists of a protocols such as UDP or TCP to allows connections over which data can be sent between hosts on the network. Uses IP underneath to implement the connections
- Application Layer -- consist of protocols like HTTP, FTP, SMTP, IMAP, POP, DNS, SSH, etc. which use TCP or UDP to give functionality to some application like a browser, mail client etc.

Clients and Servers

We will mainly be concerned with application protocol which are built on top of the transport layer.
One common model used in the transport layer is that of client and server machines on a network.
A server machine is identified on the internet by some IP address 130.65.86.46. Often we can find this IP by using a domain name lookup based on an easy to remember name such as www.cs.sjsu.edu. To do this we send this name to a domain name system (DNS) server that we know the IP address of, and that DNS server send back a record containing the IP address of the machine we are looking for.
In the server-client set-up, the server at a given IP address has processes running in the background called daemons which are listening all the time for connection requests from clients on a particular port number.
Port numbers are two bytes, some commonly used numbers are 80 (HTTP), 443 (HTTPS), 20 and 21 (FTP), 22 (SSH), 25 (SMTP).
Once a connection request comes into the server on a given port, the corresponding daemon can choose to accept it, and if so, a connection is established. Then the application layer protocol is typically used for the client to get or send data to the server.
For example if the client was a web browser, it might connect to port 80 on machine 130.65.86.46 and transmit to that server the following bytes:
```
GET / HTTP/1.0 newline
newline
```

The server might then respond by transmitting back to the client:

HTTP/1.1 200 OK
Date: Wed, 07 Oct 2009 18:11:01 GMT
Server: Apache/2.2.0 (Fedora)
Last-Modified: Mon, 17 Nov 2008 23:09:56 GMT
ETag: "f5678-2723-ad5ef900"
Accept-Ranges: bytes
Content-Length: 10019
Connection: close
Content-Type: text/html

...CS Department homepage

Checking Network Status

Android provides utilities for determining the device configuration and status of the network service.
This is typically done using the ConnectivityManager class which is used to determine whether there is any network connectivity and also to get notifications of changes to the network.

As an example, after importing android.net.*; android.content.*; android.util.*; the onStart() method of a subclass of Activity could use this class as follows:

@Override
public void onStart()
{
   super.onStart();
   ConnectivityManager cMgr = (ConnectivityManager)
      this.getSystemService(Context.CONNECTIVITY_SERVICE);
   NetworkInfo netInfo = cMgr.getActiveNetworkInfo();
   this.status.setText(netInfo.toString());
}

The output will say things like: type: Mobile, state: CONNECTED/CONNECTED, reason...
The netInfo object has methods like isAvailable, isConnected it also has a getState method.
Once you are connected you can use the IP network.

In order to get this to work you need to have the correct permissions set in the AndroidManifest.xml:

<uses-permission android:name="android.permission.INTERNET"></uses-permission>
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE">
The first is for general networking, the second is for the actual info we have above.

Creating a Server Socket

There are two devices involved in the client server architecture: the client and the server.
The mobile phone will typically be the client. So in order to test anything one typically wants to write a server as some Java program on the desktop.

The basic template for a server which listens on some port is:

import java.io.*;
import java.net.*;

public final class MyServer extends Thread
{
   private static final int PORT=8889;
   private static final int NUM_CONNECT=1;

   private MyServer() {}

   public static void main(String args[])
   {
      MyServer myServer = new MyServer();
      if(myServer !=null) {myServer.start();}
   }

   public void run()
   {
      try
      {
         ServerSocket server = new ServerSocket(PORT, NUM_CONNECT);
         Socket client = server.accept();
         
         BufferedReader reader = new BufferedReader(
            new InputStreamReader(client.getInputStream()));

         BufferedWriter writer = new BufferedWriter(
            new OutputStreamWriter(client.getOutputStream()));

         // do some reading and writing
      }
      catch(IOException ie)
      {
         ie.printStackTrace();
      }
   }
}

Communicating with a Server

On your phone, you would then want code that could communicate with this server.

An example of how you might set this up is:

package org.pollett;

import android.app.Activity;
import android.os.Bundle;
import android.net.*;
import android.content.*;
import android.util.*;

public class MyClient extends Activity
{
   public void onCreate(Bundle savedInstanceState) 
   {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
 
        this.socketButton.setOnClickListener(new OnClickListener)() {
        public void onClick(final View v) {
           socketOutput.setText("");
           String output = callSocket(ipAddress.getText().toString(),
             port.getText().toString(),
             socketInput.getText().toString());
           socketOutput.setText(output);
        } 

       }
   }

   private String callSocket(String ip, String port, String socketData) {
      Socket socket = null;
      BufferedWriter writer = null;
      BufferedReader reader =null;
      String output = null;

      try{
         socket = new Socket(ip, Integer.parseInt(port));
         reader = new BufferedReader(
            new InputStreamReader(socket.getInputStream()));

         writer = new BufferedWriter(
            new OutputStreamWriter(socket.getOutputStream()));

         writer.write("hello world"+socketData+"\n");
         writer.flush();
         output = reader.readLine();
       
  
      }
      catch(Exception e){}
      return output;
   }

}

Networking Android

Outline

Overview of Networking

Clients and Servers

Checking Network Status

Creating a Server Socket

Communicating with a Server