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 onCreate() method of a subclass of Activity could use this class as follows:

      public void onCreate(Bundle savedInstanceState) 
      {
      	String message = "";
          super.onCreate(savedInstanceState);
          setContentView(R.layout.main);
  
          try
          {
  	        ConnectivityManager cMgr = (ConnectivityManager)
  	           this.getSystemService(Context.CONNECTIVITY_SERVICE);
                  if(cMgr != null)
                  {
  	           NetworkInfo netInfo = cMgr.getActiveNetworkInfo();
          	   message = "View1 "+ netInfo.toString();
  	           Log.i("NetInfoTest", message);
  	        }
          }
          catch(Exception e)
          {
          	message = "That didn't work: "+e.toString();
              Log.i("NetInfoTest", message);
                    	
          }
          
          // example using toast
          Context context = getApplicationContext();
          int duration = Toast.LENGTH_LONG;
  
          Toast toast = Toast.makeText(context, message, duration);
          toast.setGravity(Gravity.TOP|Gravity.LEFT, 0, 0);
          toast.show();
          
          //setting text field's content
          TextView netinfoText = (TextView)this.findViewById(R.id.net_info);
          netinfoText.setText(message);
          
          Button button = (Button)this.findViewById(R.id.switch_view);
          button.setOnClickListener(this);        
      }
  
      public void onClick(View v)
      {
    	  Intent i = new Intent(this, NetInfo2.class); 
  	  startActivity(i);
      }
  

• The output will say things like: type: Mobile, state: CONNECTED/UNCONNECTED, 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.
  

More on NetInfo Example

• The NetInfoTest project has a button which allows one to switch between two views
• The two views are both mentioned in the manifest.
• On the Second View has an EditText class which shows the widget you could use for editing text.
• To test this field one needs to be able to get a soft keyboard in the emulator. To do this in the AVD manager click on ones device then edit. You need to add hardware property for the keyboard and set them to no.
• In your onCreate method, you can get the soft keyboard to show up using code like:

          InputMethodManager mgr = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
          // only will trigger it if no physical keyboard is open
          mgr.showSoftInput(netinfoText, InputMethodManager.SHOW_IMPLICIT);           
  

• To hide the keyboard you can use code like:

  InputMethodManager imm = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE);
  imm.hideSoftInputFromWindow(netinfoText.getWindowToken(), 0);
  

• Although the NetInfoTest example doesn't do it, you can animate transition between Layouts using the ViewFlipper class. An example is can be found on the Smart Androidian Site.

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();
        }
     }
  }
  

Quiz

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;
     }
  
  }
  

HTTP

• One of the most common protocols implemented on top of TCP sockets is HTTP, the hypertext transfer protocol.
• It is what is used to get web pages from a web server.
• Today we begin by look at what facilities Android has for requesting web pages.

WebView

• The easiest way to just view a web-page in Android is to:
  • Add the line:

     <uses-permission android:name="android.permission.INTERNET"></uses-permission>     
    
    

    to the manifest file
  • Add a WebView to our layout:

    <WebView  
        android:id="@+id/webview"
        android:layout_width="fill_parent" 
        android:layout_height="wrap_content" 
        />
    

  • Set the web page of the view in onCreate. (Need to import package android.webkit.*) :

    webview = (WebView) findViewById(R.id.webview);
    webview.getSettings().setJavaScriptEnabled(true);
    webview.loadUrl("http://www.pollett.org/");
    

  • It should be noted that both the browsers in Android and iPhone are built off of webkit.

More on WebView

• By default, links clicked on out of our WebView will be handled by the Android web browser.
• To handle them ourselves, we could write a subclass of WebViewClient and override shouldOverrideUrlLoading:

  private class MyWebViewClient extends WebViewClient {
      @Override
      public boolean shouldOverrideUrlLoading(WebView view, String url) {
          view.loadUrl(url);
          return true;
      }
  }
  

• Then we set the WebViewClient of our WebView with a line like:

  webview.setWebViewClient(new MyWebViewClient());
  

A Lower Level Way to Request a Page

• One common reason to use HTTP is make use of a web service.
• One might make a request of the form:

  URL/service_name/method_name/?arg1=value1&arg2=value2...
  

  which requests from the given URL the given method of the given web service with the given arguments.
• The response is typically an XML or JSON document which is the output of calling the method.
• We typically want to use data from this document, but we don't want to display it in a WebView.
• This calls for a lower level way of dealing with the web.

Request a Page Using java.net

• Using android.net, we could write code like:

  String location="URL/service_name/method_name/?arg1=value1&arg2=value2";
  String result = null;
  try {
     URL url = new URL(location);
  } catch (MalformedURLException e) {
    //handle somehow
  }
  if(url != null) {
     try {
        HttpURLConnection urlConn =
           (HttpURLConnection) url.openConnection();
  
        BufferedReader in =
           new BufferedReader(
              new InputStreamReader(
                 urlConn.getInputStream()));
        String inputLine;
        while((inputLine = in.readLine()) != null)
        {
           result += "\n" + inputLine;
        }
     }
     catch (IOException e) {
     // handle somehow
     }
  
     return result;
  }
  return null;