How to deal with SMS in Android Development

SMS is an essential part of mobile products and mobile programs. A massive most of mobile customers make use of the SMS service on their own mobiles some utilize it a large number of occasions each day. Android provides an excellent API to ensure that designers can integrate SMS technology to their applications, growing the utility and benefit of their programs. In the following paragraphs we will examine several applications which use SMS technology through the APIs supplied by Android.

How you can Launch the SMS Application Out Of Your Program.

We’re now going to produce a small application that will say &ldquohello&rdquo to the buddies by delivering an SMS message. This application will require the friend’s number in the user, then your application will launch the SMS use of the cell phones using the number the consumer joined, and lastly it’ll send a &ldquohello&rdquo message.
Step One: Allowing the UI and layout

First, produce a simple activity known as as LaunchSMS , only then do we can create the construct the following:

android:orientation=”vertical”
android:layout_width=”fill_parent”
android:layout_height=”fill_parent”
>
android:layout_width=”wrap_content”
android:layout_height=”wrap_content”
android:paddingLeft=”2dip”
android:paddingRight=”4dip”
android:text=”Recipient Number”
/>
android:layout_width=”fill_parent”
android:layout_height=”wrap_content”
android:cursorVisible=”true”
android:editable=”true”
android:singleLine=”true”
/>
android:layout_width=”fill_parent”
android:layout_height=”wrap_content”
android:text=”Say Hello!”
android:onClick=”sayHello”
/>

Above, we’ve produced a linear layout with one TextView to inform the consumer he needs to go into the recipient’s number. Then, we’ve one EditText to take the amount in the user, and something button which, when clicked on, will call the technique sayHello.

The code for that activity is the following:

package launchSMS.com
import android.application.Activity
import android.content.Intent
import android.internet.Uri
import android.os.Bundle
import android.view.View
import android.widget.EditText
public class LaunchSMS stretches Activity Known as once the activity is first produced. */
private EditText messageNumber
@Override
public void onCreate(Bundle savedInstanceState) primary)
messageNumber=(EditText)findViewById(R.id.messageNumber)

public void sayHello(View v) to state hello”
Intent sendIntent = new Intent(Intent.ACTION_VIEW)
sendIntent.setData(Uri.parse(“sms:”+_messageNumber))
sendIntent.putExtra(“sms_body”, messageText)
startActivity(sendIntent)

Step Two: Initializing the game

While using onCreate method, we’ll set primary layout we produced because the content view. Then, I’ve produced a personal member to carry the EditBox for that message number.

public void onCreate(Bundle savedInstanceState) primary)
messageNumber=(EditText)findViewById(R.id.messageNumber)

The UI for that application will appear the following:

Step Three: Starting the SMS Application

public void sayHello(View v) to state hello”
Intent sendIntent = new Intent(Intent.ACTION_VIEW)
sendIntent.setData(Uri.parse(“sms:”+_messageNumber))
sendIntent.putExtra(“sms_body”, messageText)
startActivity(sendIntent)

Within the function sayHello, we first obtain the number that the user has joined within the EditText. Then, we produce a String variable to carry the content text that you want to send.

Now, to produce the SMS application, we must produce the following:

Intent sendIntent = new Intent(Intent.ACTION_VIEW)

Then, we set the intent data using the number joined through the user the following:

sendIntent.setData(Uri.parse(“sms:”+_messageNumber))

Finally, the content text goes as extra data within the intent while using method putExtra around the intent.

sendIntent.putExtra(“sms_body”, messageText)

Then, the intent is distributed by passing the produced intent to startActivity. This can launch the SMS use of the consumer using the number and message text already prepopulated. The consumer could make edits if they wants, and they will have to press &ldquosend&rdquo to transmit the content to their friend.

So, while using intents, we are able to launch the SMS application from inside our program.
How you can Send SMS Directly Through the API Supplied by Android

Now, we will create an application where DirectSendSMS would be the enhanced form of the prior application. This application will directly send the &ldquohello&rdquo message towards the user while using Android SMS API.
Step One: Allowing the UI and Layout

First we have to produce a new activity, DirectSendSMS. The UI of the application will probably be identical to the one referred to above, so with this also we’ll produce a linear construct and add one Textiew, one EditText, and something button.

Design is the following:

android:orientation=”vertical”
android:layout_width=”fill_parent”
android:layout_height=”fill_parent”
>
android:layout_width=”wrap_content”
android:layout_height=”wrap_content”
android:paddingLeft=”2dip”
android:paddingRight=”4dip”
android:text=”Recipient Number”
/>
android:layout_width=”fill_parent”
android:layout_height=”wrap_content”
android:cursorVisible=”true”
android:editable=”true”
android:singleLine=”true”
/>

android:layout_width=”fill_parent”
android:layout_height=”wrap_content”
android:text=”Say Hello!”
android:onClick=”sayHello”
/>

Step Two: Initializing the game

The initializing from the activity can also be just like referred to in the last application. Inside the onCreate function, we set the primary layout because the content view and go ahead and take EditBox inside a private variable.

public void onCreate(Bundle savedInstanceState) primary)
messageNumber=(EditText)findViewById(R.id.messageNumber)

Step Three: Indicating the Permission for Delivering the SMS

In Android, one needs to specify all the permissions necessary for application within the AndroidManifest.xml. In so doing while setting up the application, all of the permissions needed through the application is going to be proven towards the user.

For that ability within our application to transmit messages, we have to add some android.permission.SEND_SMS permission into AndroidManifest.xml the following:

package=”directSendSMS.com”
android:versionCode=”1″
android:versionName=”1.”>

android:label=”@string/application_title”>

Step Four: Delivering the SMS

public void sayHello(View v) to state hello”
SmsManager sms = SmsManager.getDefault()
sms.sendTextMessage(_messageNumber, null, messageText, null, null)

Within the sayHello function, we obtain the amount the user joined. Inside a variable, we contain the message text that you want to send. Then, we obtain the SmsManager object the following:

SmsManager sms = SmsManager.getDefault()

Then, while using sendTextMessage approach to SmsManager, we send the content.
Step Five: Exhibiting a Toast Once the Message is Effectively Sent

public void sayHello(View v) to state hello”
String sent = “SMS_SENT”
PendingIntent sentPI = PendingIntent.getBroadcast(this, ,
new Intent(sent), )
//—once the SMS continues to be sent—
registerReceiver(new BroadcastReceiver()
else
couldn’t sent”,
Toast.LENGTH_SHORT).show()

, new IntentFilter(sent))
SmsManager sms = SmsManager.getDefault()
sms.sendTextMessage(_messageNumber, null, messageText, sentPI, null)

Now, we’ve enhanced the sayHello approach to display a Toast upon effectively delivering the content. We produce a new PendingIntent with this and pass it as being a disagreement towards the sendTextMessage method. We register a receiver with this intent, which inspections the end result code and shows a Toast saying SMS sent.

Now, the application may be like the next:

Steps To Make Your Application React to SMS Messages

Now, we will create an application which will respond when an SMS is received. This application will only display the incoming message on the Toast.
Step One: Produce a New Application

With this application, we will produce a BroadcastReciever to trap the in coming SMS message. Though we’re not creating a task with this, generally such applications can make a task for that configurations page of these applications.

This is the AndroidManifest.xml with this application:

package=”recieveSMS.com”
android:versionCode=”1″
android:versionName=”1.”>

Here, we add some android.permission.RECEIVE_SMS permission within our application to ensure that we are able to react to SMS received.
Step Two: Allowing the SMS Receiver

The code for that SMS receiver is the following:

package recieveSMS.com
import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent
import android.os.Bundle
import android.telephony.SmsMessage
import android.widget.Toast
public class RecieveSMS stretches BroadcastReceiver

Toast.makeText(context, str, Toast.LENGTH_SHORT).show()

We must produce a class which stretches BroadcastReceiver, and we must override the onRecieve Method.

Within the onRecieve method, we take away the data in the received Intent, take away the SmsMessage object, and acquire the sender’s address and text to show on the toast.
Step Three: Running the Application

To check this, you’ll need two Android emulator instances. We’ll send the SMS utilizing an SMS application in one instance to another. You’ll have the ability to begin to see the Instance number on top. As seen below, the amounts which i have are 5554 and 5556.

So in the second Instance, I’ll send an SMS towards the first instance as proven below:

When the first instance receives an SMS, the data is going to be displayed like a Toast, as proven below:

Conclusion

SMS is become this kind of integral and important a part of our mobiles today that there might be numerous different ways that SMS could be integrated inside your next killer Android application. The usability along with the abilities individuals Android applications could be elevated greatly if SMS is correctly integrated.

As seen above, Android like a platform provides excellent support to integrate SMS inside your programs. So, go available and integrate SMS into you next awesome Android application!