Processing Incoming Messages
Okay, so your BroadcastReceiver is set up to be called each time a new SMS intent hits the phone. Now, you'll need to process these incoming messages and do something with them.
Once upon a time, Android included a function called getMessagesFromIntent() which, in their infinite wisdom, they decided to remove from the 1.0 SDK. Because I'm a nice guy, I've re-written this function for you. I won't go into too much detail on it, instead I'll just give you the source code:
SmsMessage retMsgs = null;
Bundle bdl = intent.getExtras();
Object pdus = (Object )bdl.get("pdus");
retMsgs = new SmsMessage[pdus.length];
for(int n=0; n < pdus.length; n++)
byte byteData = (byte)pdus[n];
Log.e("GetMessages", "fail", e);
Again, for you copy/paste programmers, click here
for the full project data. Now that you've got the Intent extras converted into SMSMessages, check out Listing 1
to see the example onReceive
All right, that's a fair amount of code. Let's walk through it a little bit at a time. Your first task is to be sure you've received the correct Intent. To do this, you'll need to call getAction() on the passed-in Intent class.
Next, you'll need to retrieve an array of messages that are currently in the SMS hopper. This was a tough function to track down as it's incredibly poorly documented in the Android docs (this usually means that it will change in a later release). The task involves calling getMessagesFromIntent() while again passing in the intent object, which will return an array of SmsMessage objects. You'll need to loop through these messages searching for specific trigger texts. To get the messages body out of the SmsMessage object you'll have to call getDisplayMessageBody() on each SmsMessage in the array.
Again, because Android doesn't give us a chance to pull Intents out of the broadcast stack, you'll have to make the triggers humanly readable. In this little sample application, you can see two distinct triggers. The first trigger starts an application, while the second performs a GPS lookup and fires back an SMS detailing the location of the phone. We'll get into GPS information and sending SMS messages in a minute. First things first. Let's look, really quickly, at firing up an application or Activity from a BroadcastReceiver.
Waking Up the Application
Waking up your test application on an incoming SMS simply requires you, once you've received the correct SMS, to create the appropriate Intent and send it on it's way. First, you'll need an Activity with which to start your application. For those of you who are old hands at Android development, this section is going to be a bit of a review.
The first step is to add an activity to your AndroidManifest.xml file. If you started a new project from scratch (or your cheated and downloaded the source code), chances are you already have a "hello world" activity. For reference, here's what the new activity will look like, pay careful attention to the additional action in the intent receiver tag.
<application android:icon="@drawable/icon" android:label="@string/app_name">
<activity android:name=".BaseScreen" android:label="@string/app_name">
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
Insert the above listing inside the application tag alongside the receiver you defined earlier. Notice the com.devx.SMSExample.WAKE_UP
action: This is the intent you'll need to send to wake up the Activity. Here’s the source code that will wake up your sample activity:
private void triggerAppLaunch(Context context)
Intent broadcast = new Intent("com.devx.SMSExample.WAKE_UP");
Create a new Intent with the action defined above in the AnroidManifest.xml
. Because you're starting a new Activity from a BroadcastReceiver, you'll need to add the FLAG_ACTIVITY_NEW_TASK
flag to the intent before calling startActivity
. At this point, the incoming SMS message will launch your shiny new "hello world" activity. What you do with that activity at this point is your own business.