It would be safe to say that nearly every mobile phone sold in the past decade has SMS messaging capabilities. So making use of SMS with your Android app can be a great way to handle information when no Data network (3G or WIFI) is available.
In this article, we will take a look at how you can programmatically send and receive SMS messages in your Android applications.

Sending SMS Data messages

So lets start with the sender AndroidManifest.xml. I recommend you open up the sample code, as I will be highlighting the key parts on this page.

The uses-permission tag will allow the application to send SMS messages. Sending SMS message with the application will potentially incur additional cost on the user’s end.
Indicating the SMS permissions in the AndroidManifest.xml file will let the user decide whether to allow the application to install or not.

Next, we will create an activity called SendActivity that will handle sending SMS messages.

To send an SMS message, you use the SmsManager class. Unlike other classes, you do not directly instantiate this class; instead you will call the getDefault() static method to obtain an SmsManager object. The sendDataMessage() method sends the SMS message with a PendingIntent. The PendingIntent object is used to identify a target to invoke at a later time. For example, after sending the message, you can use a PendingIntent object to update the current activity, and onActivityResult will be triggered.

Receiving SMS Data messages

Besides sending SMS messages, you can also intercept incoming SMS messages using a BroadcastReceiver object.

To see how to receive SMS messages from within your Android application, lets look at the AndroidManifest.xml file within our receiver sample code.

The uses-permission tags will allow the application to receive and read SMS messages. Lets create a class that extends the BroadcastReceiver class and override the onReceive() method:

When SMS messages are received, the onReceive() method will be invoked. The SMS message is contained and attached to the Intent object via a Bundle object.
The messages are stored in an Object array in the PDU format. To extract each message, you use the static createFromPdu() method from the SmsMessage class.
The SMS message is then passed to an Activity that shows the message.

That’s it. We’ve managed to send and received a Data SMS within an Android application. Till next time.

Getting started

Before we can make use of NFC we need to add a few new tags to our manifest XML. I recommend you open up the sample code, as I will be highlighting the key parts on this page. When you have the project imported, open up AndroidManifest.xml in the XML view.

The uses-permission tag will allow us to access the NFC chip in the device, and the uses-hardware tag will make it required, which will mean our app only appears to NFC enabled devices in Google Play.
For our ReadTagActivity tag we add a new intent-filter, this will launch the activity when a tag is scanned that contains data in our format. We do this by specifying a custom mime-type, in this case I’ve chosen “application/com.elsinga.sample.nfc”. Android handles NFC tag scans by trying to find the best match for the data on the tag, providing several fallback mechanisms to make sure the tag is handled by the right app and allowing the user to pick from a chooser dialog when there is no clear target.

The first thing we need to do is write some data to a blank NFC tag, so open up WriteTagActivity.java. This activity is launched when the user clicks the “Write button” in the app’s main activity. It displays a button that, when pressed, waits for a tag to write to.

In our onCreate() we grab a reference to the NFC adapter for later use:

The NfcAdapter allows us to begin listening to a tag being scanned, before any other app gets a chance. This is called “foreground dispatch”. When the user presses the button we call enableTagWriteMode() to begin this process. In this method we set up a PendingIntent to run when a tag gets scanned, in this case we simply want the Intent to launch the current Activity when any tag gets scanned, so set up no special filters. When the system dispatches ACTION_TAG_DISCOVERED, this Activity will launch and onNewIntent() will get called with the tag details.

In onNewIntent() we pull out the NFC Tag and begin writing to it in writeTag().

NDEF

The data we store is organised into NDEF Records inside a single NDEF Message. The first thing we do is to determine whether the tag is already NDEF formatted by calling Ndef.get(tag). If it’s already NDEF formatted we check if it’s writeable and that the data is not too large. With all being well we write the data with ndef.writeNdefMessage(). That’s it, we’ve written to an NFC tag!

If you go to the home screen, or exit the app, and re-scan the tag, it should now launch the ReadTagActivity and show the text.
Open up ReadTagActivity.java to see how we read the information from the Intent:

With that determined we can go ahead and grab the NdefMessage from the Intent’s extras. In our case we know the first NdefRecord is the record we want, containing our written text in the payload:

That’s it. We have managed to write custom data to an NFC tag, and read back that custom data.
Have a look at the sample code and also discover how to beam data from one NFC-enabled device to another.

– Enable Snapshots.
Enabling snapshots on an AVD allows the emulator to start-up an AVD in the state it was in when you closed it. This means that it doesn’t have to go through the boot-up procedure each time, which will save you a reasonable chunk of time.
First on the initial launch make sure you select “Save to snapshot”. Get the emulator up and running and put it into the state you want. I like to have it start at the desktop (home screen) view. Now close the emulator. I found that it wasn’t very responsive when closing, so wait a bit, watch the mouse icon go to “busy” and let it write everything to disk.
Now, launch the emulator again and this time uncheck “Save to snapshot” but make sure Launch from snapshot is chosen. Voila! The emulator launches quickly. And when you save it it shuts down quickly because it’s not saving anymore.

While developers can implement interactions where parts of the screen change by showing and hiding views, Android’s developers decided they needed more than just convention to encourage better large screen UIs and consistent implementation of the feel of the UI. Now, in order to facilitate this new kind of interaction, as part of the Android 3.0 SDK, we get a class called Fragment.

A Fragment object is something between a View and and Activity: It can be part of a layout, but it isn’t a subclass of View.
It implements the ComponentCallbacks interface, and it has a lifecycle, but that lifecycle is dependent on the Activity the Fragment object belongs to.
Let’s see what it can do in a tablet-sized user interface.

Here are the contents of the main.xml file that describes a screen layout for our application. In a list on the left of the screen some numbers will appear. Selecting a number from that list will create that many Android icons, displayed in a Fragment instance on the right.

The code for the Fragment subclass referred to in the layout in main.xml is below.

This is what you see when you when you run the program: Initially, you see a list of numbers, and a blank area to the right.

Touch a number, and a new Fragment is created, with the specified number of Android icons. If you keep touching numbers in the list on the left, the corresponding number of Android icons appears in the Fragment instance on the right. Now try the back button. Instead of returning to an instance of the Activity that was on the screen before this application launched, you see the previous Fragment instance on the right. That is, the Fragment objects have been integrated into the task’s back stack.

Fragments are a new feature of Android, and this brief example only scratches the surface of how Fragment will change the way Android UIs are implemented. You can see from this example that using Fragments is efficient and expressive.
You can read more about Fragment, and how it can be used alongside starting Activity objects to drill into detail views in an Android UI in an article by Dianne Hackborn, here.

Download source code FragmentExample [19kB]

• Hierarchy Viewer
• Layoutopt

Hierarchy Viewer

The Hierarchy Viewer application provides a visual representation of the layout’s View hierarchy (the Layout View) and a magnified inspector of the display (the Pixel Perfect View). So lets run the tool.

1. Connect your device or launch an emulator
2. From a terminal, launch hierarchyviewer from your SDK /tools directory.
3. In the window that opens, you’ll see a list of Devices. When a device is selected, a list of currently active Windows is displayed on the right. The focused window is the window currently in the foreground, and also the default window loaded if you do not select another.
4. Select the window that you’d like to inspect and click Load View Hierarchy. The Layout View will be loaded. You can then load the Pixel Perfect View by clicking the second icon at the bottom-left of the window.

Layoutopt

Layoutopt is a command line tool which can analyse a layout resource file and tell you what is not required. So lets run the tool.

1. From a terminal, launch layoutopt from your SDK /tools directory.
2. The argument is a space- delimited list of resources you want to analyze, either non-compiled resource xml files or directories of such files.

Applications usually uses databases to store application data. Inside this article I will be explaining two implementation types:

• SQLite
• DB4o

I will use the Android application which was developed inside my previous post.

SQLite

SQLite is a lightweight relational database engine. SQLite is fast and has a small footprint, making it perfect for Android devices. Instead of the heavyweight server-based databases like Oracle and Microsoft SQL Server, each SQLite database is stored within a single file on disk. So lets set-up an implementation.

1. Create a DB Helper Class
public DbHelper(Context context) {
     super(context, DATABASE_NAME, null, DATABASE_VERSION);
}

@Override
public void onCreate(SQLiteDatabase sqliteDb) {
     String sql = "CREATE TABLE " + TABLE_NAME + " (" + COLOMN_NAME+ " LONGTEXT" + ");";
     sqliteDb.execSQL(sql);
}

@Override
public void onUpgrade(SQLiteDatabase sqliteDb, int oldVersion,
          int newVersion) {
     Log.i(DbHelper.class.getName(), "Upgrading database from version " + oldVersion + " to "
               + newVersion + ", which will destroy all old data");
     sqliteDb.execSQL("DROP TABLE IF EXISTS " + TABLE_NAME);
     onCreate(sqliteDb);
}
2. Create a Data layer class. This class will be responsible for using our DbHelper to perform our desired CRUD functions.
public void addSearchResult(String text) {
     SQLiteDatabase db = _dbHelper.getWritableDatabase();
     try {
          ContentValues values = new ContentValues();
          values.put(_dbHelper.COLOMN_NAME, text);
          db.insert(_dbHelper.TABLE_NAME, "", values);
     } finally {
          if (db != null)
               db.close();
     }
}

public void clearHistory() {
     SQLiteDatabase db = _dbHelper.getWritableDatabase();
     try {
          db.delete(_dbHelper.TABLE_NAME, "", null);
     } finally {
          if (db != null)
               db.close();
     }
}

public List<String> getHistory() {
     SQLiteDatabase db = _dbHelper.getWritableDatabase();
     try {
          List<String> results = new ArrayList<String>();
          Cursor c = db.rawQuery("select * from " + _dbHelper.TABLE_NAME, null);
          if (c.getCount() > 0) {
               c.moveToFirst();
               do {
                    results.add(c.getString(c.getColumnIndex(_dbHelper.COLOMN_NAME)));
               } while (c.moveToNext());
               }
               return results;
     } finally {
          if (db != null)
               db.close();
     }
}
3. Add CRUD functions to your Android application
Db dB = new Db(getBaseContext());
dB.addSearchResult(result);

private void clearHistory() {
     Db dB = new Db(getBaseContext());
     dB.clearHistory();
}

private void displayHistory() {
     Db dB = new Db(getBaseContext());
     List<String> history = dB.getHistory();
     
     ArrayAdapter<String> mHistory = new ArrayAdapter<String>(this, R.layout.row, R.id.ENTRY_CELL, history);
     
     historyList.setAdapter(mHistory);

}

Download source code AndroidSQLLite.zip [20kB]

DB4o

db4o is an object database, so no mapping of tables in a relational model. You can persist complex objects with nested collections or other complex objects, any level of complexity in your hierarchy. You’re not limited to flat objects with primitive types to get a reasonable performance. So lets set-up an implementation.

1. Create a persistent Object
public class HistoryItem {
     
     private String item;
     
     public HistoryItem() {
     }
     
     public HistoryItem(String item) {
          this.item= item;
     }

     public void setItem(String item) {
          this.item = item;
     }

     public String getItem() {
          return item;
     }
}
2. Create a DB Helper Class
public DbHelper(Context context) {
     try {
          if (database == null || database.ext().isClosed()) {
               database = Db4oEmbedded.openFile(configure(), db4oDBFullPath(context));
          }
     } catch (Exception ie) {
          Log.e(DbHelper.class.getName(), ie.toString());
     }
}

private static EmbeddedConfiguration configure() {
     EmbeddedConfiguration configuration = Db4oEmbedded.newConfiguration();
     configuration.common().objectClass(HistoryItem.class).objectField(
               "item").indexed(true);
     configuration.common().objectClass(HistoryItem.class).cascadeOnUpdate(true);
     configuration.common().objectClass(HistoryItem.class).cascadeOnDelete(true);
     return configuration;
}

private String db4oDBFullPath(Context ctx) {
     return ctx.getDir("data", DATABASE_MODE) + "/" + DATABASE_NAME;
}

public void close() {
     if (this.database != null) {
          this.database.close();
     }
}
3. Create a Data layer class.
public Db(Context c) {
     if(_dbHelper==null) {
          _dbHelper = new DbHelper(c);
     }
}

public void addSearchResult(String text) {
     ObjectContainer db = _dbHelper.getDatabase();
     try {
          db.store(new HistoryItem(text));
          db.commit();
     } finally {
          if (db != null) {
               db.close();
          }
     }
}

public void clearHistory() {
     ObjectContainer db = _dbHelper.getDatabase();
     try {
          ObjectSet<HistoryItem> items = db.queryByExample(new HistoryItem());
          for (HistoryItem historyItem : items) {
               db.delete(historyItem);
          }
          db.commit();
     } catch (Exception e) {
          Log.e(Db.class.getName(), e.toString());
     } finally {
          if (db != null) {
               db.close();
          }
     }
}

public List<String> getHistory() {
     ObjectContainer db = _dbHelper.getDatabase();
     try {
          List<String> results = new ArrayList<String>();

          ObjectSet<HistoryItem> items = db.queryByExample(new HistoryItem());
          for (HistoryItem historyItem : items) {
               results.add(historyItem.getItem());
          }
          return results;
     } finally {
          if (db != null) {
               db.close();
          }
     }
}
4. Add CRUD functions to your Android application
Db dB = new Db(getBaseContext());
dB.addSearchResult(result);

private void clearHistory() {
     Db dB = new Db(getBaseContext());
     dB.clearHistory();
}

private void displayHistory() {
     Db dB = new Db(getBaseContext());
     List<String> history = dB.getHistory();
     
     ArrayAdapter<String> mHistory = new ArrayAdapter<String>(this, R.layout.row, R.id.ENTRY_CELL, history);
     
     historyList.setAdapter(mHistory);

}

Download source code AndroidDb4o [2131kB]

Applications are usually designed so that a Server provides a service to a Client. Choosing an implementation depends on the requirements. Inside this article I will be explaining three implementation types:

• SOAP
• Servlet
• JSON

I will use the Android application which was developed inside my previous post.

SOAP

Simple Object Access Protocol is basically designed to provide a lightweight mechanism to exchange data in a XML format. Setting up a SOAP web service isn’t al that difficult. There is a disadvantage of using SOAP, and that’s overhead. Because there is no default SOAP support inside the Android library, I will be using kSOAP.

So lets set-up an implementation.

1. Create a server implementation
     public class Hello {
     
          public String sayHello(String name) {
               return "Hello " + name;
          }
     }
2. Create an Android implementation
3. Create a call to the server
     private void callService(SoapSerializationEnvelope envelope) {
          HttpTransportSE androidHttpTransport = new HttpTransportSE(URL);

          // Call the URL
          try {
               androidHttpTransport.call(SOAP_ACTION, envelope);
          } catch (IOException e) {
               display("Error:" + e.getClass().getName() + ": " + e.getMessage());
          } catch (XmlPullParserException e) {
               display("Error:" + e.getClass().getName() + ": " + e.getMessage());
          }
     }
4. Handle the response
     private SoapPrimitive getResultFromService(String text) {
          SoapObject request = new SoapObject(NAMESPACE, METHOD_NAME);
          SoapSerializationEnvelope envelope = new SoapSerializationEnvelope(SoapEnvelope.VER11);

          request.addProperty("name", text);

          envelope.setOutputSoapObject(request);

          callService(envelope);

          SoapPrimitive result = null;
          try {
               result = (SoapPrimitive) envelope.getResponse();
          } catch (SoapFault e) {
               display("Error:" + e.getClass().getName() + ": " + e.getMessage());
          }
          return result;
     }

Download source code BackEndWSDL [5kB] and FrondEndWSDL [114kB]

Servlet

The most simple form of exchanging data is by way of HTTP(s) with the use of Java Servlets. There’s no need to serialize to/from XML, so it can be a real time saver.

So lets set-up an implementation.

1. Create a server implementation
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
          String text = "";
          StringBuffer sb = new StringBuffer();
          try {
               BufferedReader reader = new BufferedReader(new InputStreamReader(request.getInputStream()));
               String line = reader.readLine();
               while (line != null) {
                    sb.append(line);
                    line = reader.readLine();
               }
               if (sb.length() != 0) {
                    text = sb.toString();
               }
          } catch (Exception e) {
          }

          response.setContentType("text/plain");
          response.setHeader("Cache-Control", "no-cache");

          if (StringUtils.isNotEmpty(text)) {
               response.getWriter().write(HELLO_STRING + text);
          } else {
               response.getWriter().write(HELLO_STRING);
          }

     }
2. Create an Android implementation
3. Create a call to the server
     private InputStream callService(String text) {
          InputStream in = null;
         
          try {
               URL url = new URL(SERVLET_URL);
               URLConnection conn = url.openConnection();

               
               HttpURLConnection httpConn = (HttpURLConnection) conn;
               httpConn.setRequestMethod("POST");
               httpConn.setDoInput(true);
               httpConn.setDoOutput(true);
               httpConn.connect();
               
               DataOutputStream dataStream = new DataOutputStream(conn.getOutputStream());
               
               dataStream.writeBytes(text);
               dataStream.flush();
            dataStream.close();

            int responseCode = httpConn.getResponseCode();
               if (responseCode == HttpURLConnection.HTTP_OK) {
                    in = httpConn.getInputStream();
               }
          } catch (Exception ex) {
               display("Error: Not not connect");
          }
          return in;
     }
4. Handle the response
     private String getResultFromServlet(String text) {
          String result = "";
          InputStream in = callService(text);
          if(in!=null) {
               result= convertStreamToString(in);
          } else {
               result = "Error: Service not returning result";
          }
          return result;
     }
     private static String convertStreamToString(InputStream is) {
          BufferedReader reader = new BufferedReader(new InputStreamReader(is));
          StringBuilder sb = new StringBuilder();

          String line = null;
          try {
               while ((line = reader.readLine()) != null) {
                    sb.append(line + "\n");
               }
          } catch (IOException e) {
               e.printStackTrace();
          } finally {
               try {
                    is.close();
               } catch (IOException e) {
                    e.printStackTrace();
               }
          }
          return sb.toString();
     }

Download source code BackEndServlet [242kB] and FrondEndServlet [16kB]

JSON

So SOAP has the advantage of using a model, and HTTP(s) has the advantage of being simple. There is an implementation that uses both. JavaScript Object Notation is a light-weight data-interchange format, think of it as XML on a diet

So lets set-up an implementation.

1. Create a server implementation
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
          String text = "";
          StringBuffer sb = new StringBuffer();
          try {
               BufferedReader reader = new BufferedReader(new InputStreamReader(request.getInputStream()));
               String line = reader.readLine();
               while (line != null) {
                    sb.append(line);
                    line = reader.readLine();
               }
               if (sb.length() != 0) {
                    text = sb.toString();
               }
          } catch (Exception e) {
               System.out.println(e);
          }

          response.setContentType("text/plain");
          response.setHeader("Cache-Control", "no-cache");
         
          JsonObject jsonObj=new JsonObject();
         
          if (StringUtils.isNotEmpty(text)) {
               jsonObj.addProperty(JSON_KEY, HELLO_STRING + text);
          } else {
               jsonObj.addProperty(JSON_KEY, HELLO_STRING);
          }
          PrintWriter out = response.getWriter();
          out.println(jsonObj);
     }
2. Create an Android implementation
3. Create a call to the server
     private InputStream callService(String text) {
          InputStream in = null;

          try {
               URL url = new URL(SERVLET_URL);
               URLConnection conn = url.openConnection();

               HttpURLConnection httpConn = (HttpURLConnection) conn;
               httpConn.setRequestMethod("POST");
               httpConn.setDoInput(true);
               httpConn.setDoOutput(true);
               httpConn.connect();

               DataOutputStream dataStream = new DataOutputStream(conn
                         .getOutputStream());

               dataStream.writeBytes(text);
               dataStream.flush();
               dataStream.close();

               int responseCode = httpConn.getResponseCode();
               if (responseCode == HttpURLConnection.HTTP_OK) {
                    in = httpConn.getInputStream();
               }
          } catch (Exception ex) {
               display("Error: Not not connect");
          }
          return in;
     }
4. Handle the response
     private String getResultFromServlet(String text) {
          String result = "";

          InputStream in = callService(text);
          if (in != null) {
               JSONObject jsonResponse;
               try {
                    jsonResponse = new JSONObject(convertStreamToString(in));
                    result = jsonResponse.getString("output");
               } catch (JSONException e) {
                    result = "Error: JSON Object couldn't be made";
               }
          } else {
               result = "Error: Service not returning result";
          }
          return result;
     }
          private static String convertStreamToString(InputStream is) {
          BufferedReader reader = new BufferedReader(new InputStreamReader(is));
          StringBuilder sb = new StringBuilder();

          String line = null;
          try {
               while ((line = reader.readLine()) != null) {
                    sb.append(line + "\n");
               }
          } catch (IOException e) {
          } finally {
               try {
                    is.close();
               } catch (IOException e) {
                    e.printStackTrace();
               }
          }
          return sb.toString();
     }

Download source code BackEndJSON [399kB] and FrondEndJSON [15kB]