How to create an SMS app part one – sending and receiving messages


Keep in mind that while telephones have been simply telephones? Whilst you could use your Android tool for just about anything else however sending and receiving textual content messages more often than not (even to the purpose of who prefer WhatsApp and different equipment for written communique); SMS continues to be technically one of your telephone’s number one makes use of at center. And with that during thoughts, that is nonetheless a elementary talent for us to be informed as builders.

On this two-part instructional, we will be able to take a look at how you’ll be able to move approximately making a fundamental app with a purpose to ship and obtain SMS content material, in addition to how to retrieve messages from the inbox and navigate Android’s new permissions gadget. In part two we’ll discover how to paintings with history products and services and categorize our messages…

Observe: You’ll be able to get the whole supply code from GitHub right here and I extremely suggest taking a look thru it as you learn. This can be a quite extra difficult undertaking and so it is going to lend a hand to have it there in entrance of you whilst you learn.

The fundamentals

Just like the ultimate instructional (how to construct an symbol gallery app), I will be able to be leaping into this assuming that you’ve got a fundamental familiarity with Android Studio and Java. If that may be now not the case, then I invite you to take a look at this publish on getting began with Android construction and this submit on developing an overly fundamental Android app. And in addition take a look at Gary’s Java instructional right here. With that out of the best way, allow’s get down to industry!

First, we’re going to create a brand new challenge the use of an empty process as our start line. As soon as that’s in a position, head over to the activity_main.xml and use the layout view to drag and drop your UI. This will likely make the most of three parts: a ListView for appearing our messages, an EditText for modifying new ones and a ship button for sending them. Area those out properly and perhaps upload a dash of colour. I will be able to depart that for your able palms.

hint 2

As a way to practice alongside within the code, I gave those the ids: messages, enter and ship.

Subsequent, we’re going to want to upload a few issues to our Android Show up, in order that our app has permission to get and ship messages:

<makes use of-permission android:identify="android.permission.READ_SMS" />
<makes use of-permission android:identify="android.permission.SEND_SMS" />
<makes use of-permission android:identify="android.permission.RECEIVE_SMS" />

Ah, if most effective it have been that straightforward although…

A laugh with permissions

What’s nice information for Android customers is that Android 6 comes with a few new regulations for permissions. In particular, apps that would probably be destructive to your privateness now additionally want to request permission at runtime, that means that customers can be proven a conversation asking in the event that they certainly need to permit apps to do such things as having access to their SMS messages.


Whilst additional safety is excellent news for customers, it’s a royal ache for builders because it approach we now want to undergo additional steps to get right of entry to fundamental capability. In particular, we’d like to raise our runtime permission request. To try this, we’re going to want to make two new strategies:

personal static ultimate int READ_SMS_PERMISSIONS_REQUEST = 1; public void getPermissionToReadSMS()  if (ContextCompat.checkSelfPermission(this, Happen.permission.READ_SMS) != PackageManager.PERMISSION_GRANTED)  if (shouldShowRequestPermissionRationale( Occur.permission.READ_SMS))  Toast.makeText(this, "Please permit permission!", Toast.LENGTH_SHORT).display();  requestPermissions(new String[]Take place.permission.READ_SMS, READ_SMS_PERMISSIONS_REQUEST);   @Override
public void onRequestPermissionsResult(int requestCode, @NonNull String permissions[], @NonNull int[] grantResults)  // Be certain that it is our unique READ_CONTACTS request if (requestCode == READ_SMS_PERMISSIONS_REQUEST)  if (grantResults.duration == 1 && grantResults[0] == PackageManager.PERMISSION_GRANTED)  Toast.makeText(this, "Learn SMS permission granted", Toast.LENGTH_SHORT).display(); refreshSmsInbox();  else  Toast.makeText(this, "Learn SMS permission denied", Toast.LENGTH_SHORT).display();   else  tremendous.onRequestPermissionsResult(requestCode, permissions, grantResults);  

What’s taking place right here, is that we’re checking to see whether or not the permission is granted already and if it’s now not, we’re checking whether or not we’d like to give an explanation for the location to the consumer. If this is the case, then we’re showing a toast message and both method, we’re then in reality doing the asking.


We care for the reaction by means of onRequestPermissionResult. Our toast message confirms the solution and whether it is sure, we’re then the use of our subsequent new approach, refreshSmsInbox. We handiest need to release this when we’re positive that our permission has been granted, in a different way it is going to result in tears. The excellent news is that older variations of Android don’t want those hijinks but when you wish to have to long run-evidence your app, you’re going to want to provide this a move.

Notice: Keep in mind that to import categories as you wish to have them! If code seems in pink, make a selection it and press ALT+ENTER to in finding the choice.

Showing messages

Our onCreate goes to appear to be so:

public elegance MainActivity extends AppCompatActivity  ArrayList<String> smsMessagesList = new ArrayList<>(); ListView messages; ArrayAdapter arrayAdapter; personal static ultimate int READ_SMS_PERMISSIONS_REQUEST = 1; @Override safe void onCreate(Package savedInstanceState)  tremendous.onCreate(savedInstanceState); setContentView(R.format.activity_main); messages = (ListView) findViewById(R.identity.messages); enter = (EditText) findViewById(R.identity.enter); arrayAdapter = new ArrayAdapter<>(this, android.R.format.simple_list_item_1, smsMessagesList); messages.setAdapter(arrayAdapter); if (ContextCompat.checkSelfPermission(this, Show up.permission.READ_SMS) != PackageManager.PERMISSION_GRANTED)  getPermissionToReadSMS();  else  refreshSmsInbox(); 

That is initializing an ArrayAdapter, discovering our messages ListView and environment the latter to show the previous. Briefly, it signifies that messages goes to show arrayAdapter – which we’re going to use to make our inbox messages presentable.


So all that’s left is to if truth be told get the ones messages. That’s why we’re grabbing permission proper while the app launches and then if that every one is going easily, heading over to refreshSmsInbox. And if the consumer has prior to now run the app, then we’ll be in a position to see that the permission is already granted and skip that level. When we get to refershSmsInbox, it seems like so:

public void refreshSmsInbox()  ContentResolver contentResolver = getContentResolver(); Cursor smsInboxCursor = contentResolver.question(Uri.parse("content material://sms/inbox"), null, null, null, null); int indexBody = smsInboxCursor.getColumnIndex("frame"); int indexAddress = smsInboxCursor.getColumnIndex("cope with"); if (indexBody < 0 || !smsInboxCursor.moveToFirst()) go back; arrayAdapter.transparent(); do  String str = "SMS From: " + smsInboxCursor.getString(indexAddress) + "n" + smsInboxCursor.getString(indexBody) + "n"; arrayAdapter.upload(str);  at the same time as (smsInboxCursor.moveToNext());

This time it’s slightly easy: we’re the use of the Uri to get messages from the inbox and we’re grabbing the frame and cope with. We’re the use of the cursor to undergo each and every message, combining the ones two parts right into a string (over two strains – ‘n’ approach new line) and then populating the ListView with them. This now provides us an inventory of actually all our messages, which isn’t precisely typical for a messaging app… however hello ho!

Sending messages

Sending messages is fortunately going to be even more effective and in part it’s because permissions in Android are arranged as teams. In the event you request permission for one factor within the staff, you then routinely achieve permission for all movements in that workforce (which does provide a few safety problems, in fact). On this case, as a result of we requested for permission to view our consumer’s messages, that suggests we don’t want to ask for permission once more so as to ship them!


Therefore, we will be able to use a easy onClick on our button and then ship our messages:

EditText enter;
SmsManager smsManager = SmsManager.getDefault(); public void onSendClick(View view)  if (ContextCompat.checkSelfPermission(this, Occur.permission.SEND_SMS) != PackageManager.PERMISSION_GRANTED)  getPermissionToReadSMS();  else  smsManager.sendTextMessage("YOUR PHONE NUMBER HERE", null, enter.getText().toString(), null, null); Toast.makeText(this, "Message despatched!", Toast.LENGTH_SHORT).display(); 

I like to recommend including your personal quantity for now. This bit actually is that straightforward, which makes a pleasant amendment!

Intercepting messages

It wouldn’t be an excellent SMS app in the event you had to refresh it each and every time you were given a brand new message even though! And that’s why we’d like to be in a position to intercept incoming messages too. To try this, we first want to upload slightly of code originally of our This may increasingly lend a hand us to keep up a correspondence among categories and will have to glance as follows:

public static MainActivity example()  go back inst;
public void onStart()  tremendous.onStart(); inst = this;

Now we’d like to create a brand new Java Elegance, referred to as SmsBroadcastReceiver. That is going to include the next code:

public elegance SmsBroadcastReceiver extends BroadcastReceiver  public static ultimate String SMS_BUNDLE = "pdus"; public void onReceive(Context context, Purpose cause)  Package intentExtras = reason.getExtras(); if (intentExtras != null)  Item[] sms = (Item[]) intentExtras.get(SMS_BUNDLE); String smsMessageStr = ""; for (int i = 0; i < sms.duration; ++i)  String layout = intentExtras.getString("layout"); SmsMessage smsMessage = SmsMessage.createFromPdu((byte[]) sms[i], layout); String smsBody = smsMessage.getMessageBody().toString(); String cope with = smsMessage.getOriginatingAddress(); smsMessageStr += "SMS From: " + cope with + "n"; smsMessageStr += smsBody + "n";  MainActivity inst = MainActivity.example(); inst.updateInbox(smsMessageStr);  

This may spring into motion each time a brand new SMS is won (so long as the app is open) and will then take a look at the information that’s coming in and organize it into an invaluable string made from who the message is from and the real content material. identical to sooner than.


And after all, you wish to have to upload this to your take place, within the software tag however out of doors the process tag.

<receiver android:identify=".SmsBroadcastReceiver" android:exported="actual" > <reason-clear out android:precedence="999" > <motion android:identify="android.supplier.Telephony.SMS_RECEIVED" /> </cause-clear out>

As you used your personal quantity to ship the SMS, you’ll in finding that any messages you ship will have to routinely seem on your ListView, confirming that this has all labored simply properly. Or now not. That may be indisputably additionally imaginable…

Subsequent time: making this into an invaluable app

You presently have a quite practical SMS app, that allows you to permit you to view all of the messages in your telephone and ship new messages to your self. Tremendous helpful…

Subsequent time, we’ll take a look at turning this fundamental construction block into one thing we will be able to in fact use. To try this we will be able to want to setup the app in order that it’s continuously in search of new messages, in order that it doesn’t have to be open to paintings. We’ll discover how to use history products and services to that finish.

We’ll even be tidying up the UI, categorizing messages via sender and letting the consumer come to a decision who the recipients for his or her messages will have to be. Perhaps we’ll upload a few touch icons as smartly, relatively than simply having a wall of textual content.


Via doing all this, we will be able to expectantly be in a position to construct an absolutely useful messaging app identical to the one that got here pre-loaded for your telephone. From there, you’ll be able to head off and provide it your personal flare. However why prevent there? Why now not veer off the crushed trail and check out one thing utterly other? How approximately construction a device for organizing your SMS messages? Or for backing them up? What approximately an individual one-to-one messaging carrier that deletes the messages right away as you ship them to a unmarried individual on your inbox? There are plenty of choices, so get creative!

For now, optimistically this has given you an advent to a few fundamental ideas that you’ll be able to deliver to your subsequent challenge, whether or not that’s an SMS app or one thing else totally. Subsequent time, we’ll make bigger the ones ideas into one thing absolutely useful. See then you!


Marshmallow Man, blog spiritual leader, has strived to make AppMarsh an independent and free blog from world monetary system. He and his followers are exiled by Google monster.