Sending SMS on Android and tracking it

Lets look at how to send an SMS. It’s pretty simple though. A few lines of code and your SMS is gone. To make it more convenient and meaningful, we should also be able to track and let the user know when the SMS is sent and when it is delivered. For a start, I won’t be looking into how to trap the error messages here and log or show it to the user. May be, when I get some more time, I will update this post. For now, lets track our SMS.

        Intent sentIntent = new Intent(INTENT_ACTION_SENT);
        PendingIntent pendingSentIntent = PendingIntent.getBroadcast(this,
                REQUEST_CODE_ACTION_SENT, sentIntent,

        Intent deliveryIntent = new Intent(INTENT_ACTION_DELIVERY);
        PendingIntent pendingDeliveryIntent = PendingIntent.getBroadcast(this,
                REQUEST_CODE_ACTION_DELIVERY, deliveryIntent,

        SmsManager smsManager = SmsManager.getDefault();

        // Second parameter is the service center number. Use null if you want
        // to use the default number
        smsManager.sendTextMessage(number, null, message, pendingSentIntent,

In the above code snipped, you can see that we are passing 2 pending intents to the SMSManager, one of which will be fired when the SMS is sent, and the other, when the SMS is delivered. It would also let you know the error type if the sending or delivery fails, so that you can take action for the errors. INTENT_ACTION_SENT and INTENT_ACTION_DELIVERY are string constants, which are just some random actions required to setup of the PendingIntents and receive them back.

Setting up the SMS is super easy. How do we track or listen to the updates, which happen through the PendingIntents? Well, those pending intents could be for starting an Activity, a Service or sending out a Broadcast. As you can see, here, I have used a Broadcast, to keep it simple. So, in our activity, we would need to register BroadcastReceivers for the same actions.

        IntentFilter filter = new IntentFilter(INTENT_ACTION_SENT);

        registerReceiver(smsSentDeliveredReceiver, filter);

Now, the onReceive() method will be fired, when those events happen, and thus you can notify the user about when the message is sent and delivered.

        String action = intent.getAction();
        Log.i(TAG, “Received: ” + action);

        if (action.equals(INTENT_ACTION_SENT)) {
            Log.i(TAG, “Message: Sent”);
            Toast.makeText(this, “Message sent”, Toast.LENGTH_LONG).show();
        } else if (action.equals(INTENT_ACTION_DELIVERY)) {
            Log.i(TAG, “Message: Delivered”);
            Toast.makeText(this, “Message delivered”, Toast.LENGTH_LONG).show();

You can find the sample app and the source code here. Give it a run.

Note: Using this example, you cannot send SMS to real numbers from an emulator. The SMS will be sent, but it will never be delivered.

Download Videos from Youtube Trick

First things first. Is it legal to download videos from Youtube?

As much I have understood from the Terms of Service, it’s not a straight yes or no. Basically, Youtube doesn’t have a publicly available API or service that would allow users to download the videos. Of course, you can download back the videos that you had originally uploaded. But who would do that anyway?

However, there are workarounds and tricks with which you can actually download any video from the website. There are many softwares/add-ons that easily do this job. Here is a snapshot from the published “Terms of Service“.

You shall not download any Content unless you see a “download” or
similar link displayed by YouTube on the Service for that Content. You
shall not copy, reproduce, make available online or electronically
transmit, publish, adapt, distribute, transmit, broadcast, display,
sell, license, or otherwise exploit any Content for any other purposes
without the prior written consent of YouTube or the respective licensors
of the Content. YouTube and its licensors reserve all rights not
expressly granted in and to the Service and the Content.
From Youtube Terms of Service

It says, that you cannot exploit the content/content-owners by selling the videos or re-distributing it, thereby, making a profit against your sales. That’s obviously illegal for any kind of content, unless of course, the license makes that content freely re-distributable. So, if you download the videos using those workarounds and tricks, only for your personal use (ex, offline viewing), you probably aren’t breaking any rules. What about those add-ons/softwares that do this? Well, it’s not illegal for them, since they are just distributing the software. So, they are off the hook.

For personal use, it seems ok to download videos off from Youtube. So? let’s see how hard or difficult it is to get this working.Actually, it’s quite simple.

Step 1: You should have the VIDEO ID of the video that you want to download.

Step 2: You need to make a call to this api, to get the details for that video. The fmt parameter is for getting the specified format of the videos. See the “Quality and Codecs” section on this page on Wikipedia.

URL =>

Step 3: Process the response. You will get a plain string response. That response contains all the direct URLs to various formats of the video. Look for the key “url_encoded_fmt_stream_map” and the value for this key is what you need from this response. You will need to filter out all the URLs from here, and get hold of the URL to the format you want to download. Here are some sample URLs.,expire,ip,ipbits,itag,source,ratebypass,cp&fexp=904510,914501,908302,902315,916201,905267&itag=45&ip=; codecs=”vp8.0, vorbis”&itag=45,expire,ip,ipbits,itag,source,ratebypass,cp&fexp=904510,914501,908302,902315,916201,905267&itag=22&ip=; codecs=”avc1.64001F, mp4a.40.2″&itag=22

 If you notice the URLs, there is a type parameter, where you can determine which URL is for which format (type=video/mp4, type=video/webm etc).

Step 4: To finally be able to download the video, you need to strip off a few values from these URLs, just to make sure your calls don’t fail due to long URLs. What I have noticed is that if you strip off (everything after the quality param) the last parts of the URLs, everything’s just fine. So, the final URL would be something like:,expire,ip,ipbits,itag,source,ratebypass,cp&fexp=904510,914501,908302,902315,916201,905267&itag=22&ip=

Step 5: Save the file with the proper extension. That’s it. You are done.

If you ask how I got to know about this trick? Well, everything’s already out there on the web. A lot of people have already blogged about it before. But, I had to dig for it for almost 2 days. So, I hope someone finds it useful. So, if you want to make your own Youtube Downloader, now you know “How to Download Youtube Videos programmatically”. 

Note: This method might stop working as and when Google/Youtube blocks this loophole. In the past, Youtube has been known to block a few other workarounds that had existed.

Bluetooth on Android : Part I

This is a part of a series of posts in which I will put forward a full working app what uses bluetooth on your Android device to discover, connect, pair, send and receive files. The source code would be tagged with each part of this series.

Part 1: The app should be able to discover and list out the devices (paired/unpaired).

To start off with learning about bluetooth on Android, visit the official documentation. The documentation is quite lucid and clear. Here I will try to explain parts of my code.

The first activity (HomeActivity), for now, will have a single button “Discover Devices”, which will take you to the activity(DiscoverDevicesActivity) where you can see the list of devices that are visible by your device.

This activity does a few things, quite a few if-else conditions.

  • First, you need to check if your device supports bluetooth. If you don’t have the hardware capability on your phone, you won’t be able to run this application. Eh!! Most of the phones would obviously have bluetooth. Ummm…Yes… But the emulators don’t. Arrggghhh!!!!
  • Once you are sure that your device has bluetooth capability, the next thing to check if it is enabled or not. If it’s enabled, move on to the next step, else you will need to turn it on first.
Intent intent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);

startActivityForResult(intent, REQUEST_ENABLE_BT);

  • Once, you click on “Yes” on the confirmation dialog that you will see, bluetooth radio will be switched on for you. On the screen, the “Scan” button will become active. Once you tap the “Scan” button, the ListView will show the list of devices that your device can discover.

That’s all for the first part of the series. But, there’s a little more to understand abut discovery.

The process of discovery is asynchronous. The list view, currently shows two kinds of devices.

  1. Devices which your phone already knows about (Paired)
  2. Devices which are discovered (Which are not paired with your device)

Getting the already paired devices is simple. The BluetoothAdapter will give you details about such devices.

// Check already discovered devices

Set<BluetoothDevice> devices = bluetoothAdapter.getBondedDevices();
for (BluetoothDevice device : devices) {

Now comes the actual discovery part. For this, you will need to register a broadcast receiver which will be called whenever a new device is found. After registering the receiver, you need to trigger the discovery by calling the startDiscovery() method of the BluetoothAdapter.

// Scan for new devices
IntentFilter filter = new IntentFilter(BluetoothDevice.ACTION_FOUND);
registerReceiver(devicesReceiver, filter);


On the receiver’s onReceive() method, we pick up the details about the new device found, and add it to our ListView.

public void onReceive(Context context, Intent intent) {
      String action = intent.getAction();
      // When discovery finds a device
      if (BluetoothDevice.ACTION_FOUND.equals(action)) {
          Log.i(TAG, “Device found”);
          // Get the BluetoothDevice object from the Intent
          BluetoothDevice device = intent
          // Add the name and address to an array adapter to show in a ListView


The DevicesAdapter is a custom adapter for the ListView which we will be updating in the subsequent posts to show more information about the devices.

As always, you should unregister your receiver, once your activity is paused. Also, in addition to this, you should also cancel the discovery if at all you have started by calling the cancelDiscovery() method of the BluetoothAdapter.

The part 1 of the project can be checked out by fetching the source code and checking out the v1.0 tag from the repository. The complete source code can be found here.

Alternately, if you want to download the source of Part 1 as a zip, use this link to Part 1.

Flip animation in Android

I love animations. Let’s see the video first. If you are excited, go peek at the code.
In this example, the main layout contains two ImageView widgets with two different images that are to be animated. The image views actually overlapp each other, at first, but as the animation starts, only one of them is visible at a time, while the other is invisible.
For the animation, we are using a FlipAnimator class, which extends the Animation class. Here is how we need to initialize and setup the animation.
FlipAnimator animator = new FlipAnimator(imageViewOriginal, imageViewFlip,
                        imageViewFlip.getWidth() / 2, imageViewFlip.getHeight() / 2);
 if (imageViewOriginal.getVisibility() == View.GONE) {

 There is a small check to tell the animator where to reverse the animation. This is not the perfect way, but you will get an idea. To initialize the animator, you will need to pass the original view and the flipped view and the x and y position of the axes about which it will be flipped.

The animator, internally uses a AccelerateDecelerateInterpolator.
“An interpolator where the rate of change starts and ends slowly but
accelerates through the middle.”

The main logic of the animation is written inside this method:
protected void applyTransformation(float interpolatedTime, Transformation t)

You can find the whole source code here


Understanding Intents and Intent-Filters in Android

Intents or Intent messaging is the Android’s way to pass messages/information to various components of Android. An Intent object contains information that the target component can act upon. Through Intents, your apps can trigger Activities, Services and Broadcast Receivers.
The most common use of intents in any application is to directly launch
an Activity or Service to perform action on the data being passed with
the Intent object.

A sample use of Intent is shown in the following example.
1. To launch an Activity

Intent intent = new Intent(context, TagetActivity.class);

2. To launch a Service

Intent intent = new Intent(context, TargetService.class);

To pass some data within your intents you need pass them within the Intent object like this.

intent.put(key, value);

This way you can pass basic data-types that are supported by the
Intent class. In these examples, we are specifying the component names
explicitly, i.e, TagetActivity activity and TargetService service. These
intents are examples of Explicit Intents wherein you specify the target component that you want to handle your data.

There would be situations where you would want the user to choose the
target component, or to put in another way, the target component is
determined dynamically at run-time depending on various factors. For an
example, you would like to write a E-Mail app. The basic requirement
would be that whenever a user clicks on an e-mail address, your app
should be triggered, and it should be designed to capture the e-mail
address that was clicked. This is where, Implicit Intents
come into picture. Since, the e-mail address link that the user clicks
on might not necessarily be a part of your application, you do not have
the privilege of launching your Compose Activity on the click event of
the link. What would you do in such a case?

What happens when the e-mail link is clicked?
When an email link is clicked, the app would create an Implicit Intent
setting it up with the proper data and broadcast it. Something like

Intent intent = new Intent();
intent.put(Intent.EXTRA_EMAIL, {email addresses}];

In the above code snippet, we can see that the Intent here doesn’t
specify the component name. However, it specifies an action and the list
of email addresses. For this example, we just need to pass a string
array with just one email address that the user has clicked on.

How would Android know which activity should be launched (or service
for example). In such cases, Android tries to find the best match, i.e,
the component that can handle such a payload. In case it finds multiple
components, it gives the user a choice to make. For instance, if you
have multiple email clients installed and all of them can handle such
type of Intents, the user gets a list of all these apps (see image). He
can then select one which would launch that particular component
(Activity for this example). If it fails to find any components to
handle this Intent, an exception will be thrown (ActivityNotFoundException
in this case). Here we have two email applications that can handle this
intent. The user is given a choice to select one of them when an e-mail
link is clicked. Depending on the user’s choice, the corresponding
activity will be launched.

How do we write an Activity that can handle such Intents?

We have to specify or rather design one of our activity, the compose
screen of our email client that can handle such intents. For that, we
need to specify Intent-Filters for this specific activity in the AndroidManifest.xml file.

<activity android:name=”.ComposeActivity”
    <intent-filter android:label=”@string/app_name”>
         <action android:name=”android.intent.action.SEND” />
         <data android:scheme=”mailto” />
         <category android:name=”android.intent.category.DEFAULT”/>

The above code itself is self-explanatory. Your activity now can handle
intents that are launched with this signature. The action is “android.intent.action.ACTION_SEND
and the data scheme is “mailto”, i.e, any email address. So, in your
ComposeActivity, you can retrieve the email address list by querying the
intent for the key, EXTRA_EMAIL
and you will get the list of email addresses (one in this case).
Typically, you will need to populate the Send To address field of your
ComposeActivity now.

The intent resolution process tries to find a best match for the intent.
Once it finds an Intent and launches the Activity with or without user
interruption(in case multiple matches are found), the responsibility of
handling the intent now lies with the target component. To finish off
the article, here is the way to extract the email address that had been

Bundle data = getIntent().getExtras();
String[] emailAddresses = data.get(Intent.EXTRA_EMAIL);

The developer docs
on Intent, Intent Filters and Intent Resolution mechanism is a nice
read to understand the Intent mechanism of Android. You can find other
examples of the types of data and schemes that you can design your apps