Notifications - Android Tutorial for Beginners (Part 6)

We have seen Activities and Intents. Now we need to move on to services. However, since services mostly interact with a user through notifications, I felt the need to introduce a simple program to deal with Notifications.

What are Notifications? The name itself implies their functionality. They are a way of alerting a user about an event that he needs to be informed about or even take some action on getting that information.

Notification on Android can be done in any of the following ways:

• ·         Status Bar Notification
• ·         Vibrate
• ·         Flash lights
• ·         Play a sound

From the Notification, you can allow the user to launch a new activity as well. Now we will look at status bar notification as this can be easily tested on the emulator.

To create a status bar notification, you will need to use two classes: Notification and NotificationManager.

• ·         Notification – defines the properties of the status bar notification like the icon to display, the test to display when the notification first appears on the status bar and the time to display.
• ·         NotificationManager is an android system service that executes and manages all notifications. Hence you cannot create an instance of the NotificationManagerbut you can retrieve a reference to it by calling the getSystemService()method.

Once you procure this handle, you invoke the notify()method on it by passing the notification object created.

So far, you have all the information to display on the status bar. However, when the user clicks the notification icon on the status bar, what detailed information should you show the user? This is yet to be created. This is done by calling the method setLatestEventInfo()on the notificationobject. What needs to be passed to this method, we will see with an example.

You can download the code for a very simple Notification example here:

The code is explained below:

Step 1: Procure a handle to the NotificationManager:

            privateNotificationManager mNotificationManager;

      …

mNotificationManager =

      (NotificationManager)getSystemService(NOTIFICATION_SERVICE);

Step 2: Create a notification object along with properties to display on the status bar

finalNotification notifyDetails =
new Notification(R.drawable.android,"New Alert, Click Me!",System.currentTimeMillis());

Step 3: Add the details that need to get displayed when the user clicks on the notification. In this case, I have created an intent to invoke the browser to show the website http://www.android.com

Context context = getApplicationContext();

     

CharSequence contentTitle = "Notification Details...";

     

CharSequence contentText = "Browse Android Official Site by clicking me";

Intent notifyIntent = new Intent(android.content.Intent.ACTION_VIEW,Uri.parse("http://www.android.com"));

     

PendingIntent intent =

      PendingIntent.getActivity(SimpleNotification.this, 0,

      notifyIntent, android.content.Intent.FLAG_ACTIVITY_NEW_TASK);

notifyDetails.setLatestEventInfo(context, contentTitle, contentText, intent);

Step 4: Now the stage is set. Notify.

       

      mNotificationManager.notify(SIMPLE_NOTFICATION_ID, notifyDetails);

Note that all of the above actions(except getting a handle to the NotificationManager) are done on the click of a button “Start Notification”. So all the details go into the setOnClickListener() method of the button.

Similarly, the notification, for the example sake is stopped by clicking a cancel notification button. And the code there is :

mNotificationManager.cancel(SIMPLE_NOTFICATION_ID);

Now, you may realize that the constant SIMPLE_NOTIFICATION_ID becomes the way of controlling, updating, stopping a current notification that is started with the same ID.

For more options like canceling the notification once the user clicks on the notification or to ensure that it does not get cleared on clicking the “Clear notifications” button, please see the android reference documentation. 

Fetching Result from a called activity - Android Tutorial for Beginners – (Part 5)

The next logical step in learning the Android development is to look at how can you call or invoke one activity from another and get back data from the called activity back to the calling activity. For simplicity sake, let us name the first calling activity as parent activity and the invoked activity as the child activity.

For simplicity sake, I use an explicit intent for invoking the child activity. For simple invocation without expecting any data back, we use the method startActivity(). However, when we want a result to be returned by the child activity, we need to call it by the method startActivityForResult(). When the child activity finishes with the job, it should set the data in an intent and call the method setResult(resultcode, intent)to return the data through the intent.

The parent activity should have overridden the method onActivityResult(…)in order to be able to get the data and act upon it.

NOTE: for successful execution of this sequence of events, the child activity should call finish() after setResult(..)in order to give back the handle to the parent activity.

In summary, here are the methods to implement in the parent activity:

• 1.  startActivtyForResult(..)
• 2.  onActivityResult(…)

The child Activity should complete the work as usual and finally call:

• 1.  setResult(…)
• 2.  finish()

Let us delve into the example downloadable here:

The calling Activity is providing 2 buttons to view books and pens. On selecting one of them, either BooksActivityor PensActivityis called, which displays a list (using ListView) of the selected type of objects. The user can select one and the selected object is returned to the parent for display. (Note: this could be extended into a shopping cart example. I have kept it simple for the tutorial’s sake)

Since we are expecting to get back the selected object, the calling Activity’s code is like this:

     Intent bookIntent = new Intent();                bookIntent.setClass(CallingActivity.this,BooksActivity.class);

      startActivityForResult(bookIntent,BOOK_SELECT);

where BOOK_SELECT is just a constant to help us identify from which child activity the is result obtained, when there is more than 1 child activity, as in this case.

At this point the control is handed over to the BooksActivity. This displays the list of books and the user can scroll through and select a book. When the user selects a book, the selected book needs to be passed back to the CallingActivity. This is how it is done:

      Object o = this.getListAdapter().getItem(position);

      String book = o.toString();

      Intent returnIntent = new Intent();

      returnIntent.putExtra("SelectedBook",book);

      setResult(RESULT_OK,returnIntent);       

      finish();

The first 2 lines show how to get the selected book from the ListView. Then, you create a new intent object, set the selected book as an extra and pass it back through the setResult(…)method call. The result code is set to RESULT_OKsince the job has been successfully done.  After that the finish()method is called to give the control back to the parent activity.

In the parent, the method that gets the control is onActivityResult(…)

protected voidonActivityResult(int requestCode, int resultCode, Intent data)

      {

      switch(requestCode) {

      case BOOK_SELECT:

            if (resultCode == RESULT_OK) {

                String name = data.getStringExtra("SelectedBook");

                Toast.makeText(this, "You have chosen the book: " + " " + name, Toast.LENGTH_LONG).show();

                break;

            }

      ……….

      }

      }  

Here you notice that the BOOK_SELECTconstant is used to act upon the result. If the result code is RESULT_OK, we take the book selected from the “extra” of the intent that is returned from the child activity. data.getStringExtra("SelectedBook") is called to and the name returned is displayed through a Toast. 

Pre-Packaged Applications | Android Tutorial for Beginners (Part 4)

There are many applications that can pre-packaged into the android platform that can be reused by custom built applications because of the power of the android design that is based on implicit intents.(See part 3 of this series for implicit intents).

Here we will explore how to invoke the pre-packaged applications from our own through implicit intents. Note that in none of the snippets below, we actually call the pre-packaged or system applications. We just declare intents and pass them to an activity while starting the activity through startActivity() method. However, for each of these intents, the android platform finds the most befitting activity and invokes the same:

1. Call a number

      Intent callNumber = new Intent();

      callNumber.setAction(android.content.Intent.ACTION_CALL);

      callNumber.setData(Uri.parse("tel:9440012345"));

startActivity(callNumber);

This will call the number 9440012345. For calling custom numbers, you could provide the user with a edit text field from which you can access the number and set it to the data above instead of a hard-coded number.

2. Browse the web for a given url:

      Intent searchGivenText = new Intent(Intent.ACTION_WEB_SEARCH);

      searchGivenText.putExtra(SearchManager.QUERY, "Android Examples);

      startActivity(searchGivenText);

This will invoke the Google search engine to search the string "Android Examples" and return the results to you. This too can be generalized to accept a string from the user and set to the intent before starting the activity.

3.  View google maps for a given location

      Intent searchAddress = new Intent(Intent.ACTION_VIEW, 

      Uri.parse("geo:0,0?q=Bangalore"));

startActivity(searchAddress);

This shows the location of Bangalore on Google Maps.

4. View Contacts on the phone

Intent contacts = new Intent();

      contacts.setAction(android.content.Intent.ACTION_VIEW);

      contacts.setData(People.CONTENT_URI);

      startActivity(contacts);

I have created an Android eclipse project which showcases all of these examples by taking inputs from the end user. You can access the same here.

--------
Updated on March 31 2010:

The above example uses Android SDK 1.5 From SDK 1.6 and above, the Contact.People class has been deprecated and we need to use the ContactsContract class. So the line in code
      contacts.setData(People.CONTENT_URI);
has to be replaced by
              contacts.setData(ContactsContract.Contacts.CONTENT_URI);

Here is the complete source code that has been tested with Android SDK 2.1

Implicit Intent | Android Tutorial for Beginners (Part 3)

We have seen in Part 2 how to use Explicit Intents to invoke activities through a very simple example. Now, we will move on to a more interesting concept of Implicit Intents and Intent Filters. 

This requires a little of theoretical understanding before we move on to an example. 

As described earlier, an implicit intent does not name a target component that should act upon the intent. I 

also said that the android platform resolves as to which component is best suited to respond to an Implicit Intent. How does this happen?

Basically, an Intent object has the following information (among other things like Component name, extras and flags) which is of interest for implicit intents:

• Action
  
• Category
  
• Data
  

So, the android platform compares these 3 (action, category and data) to something called "Intent Filters" that are declared by probable target components who are willing to accept Implicit Intent calls.

i.e. Intent Filters are the way of any component to advertise its own capabilities to the Android system. This is done declaratively in the AndroidManifest.xml file.

So here are some important points to remember:

1. Implicit Intents do not specify a target component
   
2. Components willing to receive implicit intents have to declare their ability to handle a specific intent by declaring intent filters
   
3. A component can declare any number of Intent Filters
   
4. There can be more than one component that declares the same Intent Filters and hence can respond to the same implicit intent. In that case the user is presented both the component options and he can choose which one he wants to continue with
   
5. You can set priorities for the intent filters to ensure the order of responses.
   

There are 3 tests conducted in order to match an intent with intent filters:

1. Action Test
   
2. Category Test
   
3. Data Test
   

For more details about them, you may visit the Android developer documentation here.

Finally we shall look at declaring an implicit intent in one activity which will invoke one of the native activities of the platform by matching the intent filters declared by the same.

The complete code for a very simple implicit intent example that has been described in this article is available for download here.

The InvokeImplicitIntent Activity creates an implicit intent object "contacts". This intent object's component is not set. However, the action is set to "android.content.intent.ACTION_VIEW" and the data's URI is set to "People.CONTENT_URI". 

Such an intent matches with the intent filter declared by the view contacts native activity.

So, when you run this application, it displays the native UI for viewing the existing contacts on the phone!

Here is the relevant piece of code for the same:

           Button viewContacts = (Button)findViewById(R.id.ViewContacts);

        
            viewContacts.setOnClickListener(new OnClickListener() {
            
             public void onClick(View v) {
              Intent contacts = new Intent();
              contacts.setAction(android.content.Intent.ACTION_VIEW);
              contacts.setData(People.CONTENT_URI);
              startActivity(contacts);
             }
            });

In this manner many of the native applications can be seamlessly invoked as one of the activities in our applications through implicit intents.

---------------------------------------------------------------------------------------------------------
Updated on 31st March 2010:
The above example uses Android SDK 1.5.
From SDK 1.6 and above, the Contact.People class has been deprecated and we need to use the ContactsContract class. So the line in code
       contacts.setData(People.CONTENT_URI);

has to be replaced by

       contacts.setData(ContactsContract.Contacts.CONTENT_URI);

Here is the complete source code that has been tested with Android SDK 2.1

Explicit Intent | Android Tutorial for Beginners (Part 2)

Having introduced you to the basic anatomy of an android application in the Part 1 of the series, I would like to show you an example where communication between 2 activities happens through an intent.

However, just one more detail to be introduced as promised and that is -

There are 2 types of intents that Android understands.

1. Explicit Intent

2. Implicit Intent

In an Explicit intent, you actually specify the activity that is required to respond to the intent. In other words, you explicitly designate the target component. This is typically used for application internal messages.

In an Implicit intent (the main power of the android design), you just declare an intent and leave it to the platform to find an activity that can respond to the intent. Here, you do not declare the target component and hence is typically used for activating components of other applications seamlessly

Note: Here for simplicity sake I tell an activity responds to an intent, it could as well be other types of components.

Now I will jump into the example which you can download from here:

This example has 2 activities:
1. InvokingActivity
2. InvokedActivity
The InvokingActivity has a button "Invoke Next Activity" which when clicked explicitly calls the "InvokedActivity" class.
The relevant part of the code is here:

        Button invokingButton = (Button)findViewById(R.id.invokebutton);
        invokingButton.setOnClickListener(new OnClickListener() {
        
         public void onClick(View v) {
         Intent explicitIntent = new Intent(InvokingActivity.this,InvokedActivity.class);
         startActivity(explicitIntent);
         }
        });

As explained in part 1 of the series, this is very much like an API call with compile time binding.

NOTE: The layout for InvokingActivity is defined in main.xml and for InvokedActivity in InvokedActivity.xml. The downloadable example can be opened in Eclipse Ganymede as an android project and can be executed.

In the next part of the series, we will see how to work with implicit intents which also needs us to understand intent-filters. 

Fundamentals | Android Tutorial for Beginners (Part 1)

This is Part 1 of a series of articles I plan to write to simplify the new paradigms introduced by the Android platform for developers.

The part 1 will only define and introduce the fundamental building blocks of Android. Later articles will provide sample code focusing on one aspect at a time, more to drive home to concept than to show any great programming skills.

From a developer's perspective, the fundamental building blocks / components of Android are:

1. Activities

2. Services

3. Broadcast Receivers

4. Content Providers.

The means of communication between the above mentioned components is through

1. Intents

2. Intent Filters

The User Interface elements are by using what are called:

1. Views

2. Notifications

Now, having broadly classified the basics, I would like to give a simple definition for each of them, before we can appreciate the need for each of them.

Activity is the basic building block of every visible android application. It provides the means to render a UI. Every screen in an application is an activity by itself. Though they work together to present an application sequence, each activity is an independent entity.

Service is another building block of android applications which does not provide a UI. It is a program that can run in the background for an indefinite period.

Broadcast Receiver is yet another type of component that can receive and respond to any broadcast announcements.

Content Providers are a separate league of components that expose a specific set of data to applications.

While the understanding and knowledge of these four components is good enough to start development, the knowledge of the means of communication between the components is also essential. The platform designers have introduced a new conpect of communication through intents and intent filters.

Intents are messages that are passed between components. So, is it equivalent to parameters passed to API calls? Yes, it is close to that. However, the fundamental differences between API calls and intents' way of invoking components is

1. API calls are synchronous while intent-based invocation is asynchronous (mostly)

2. API calls are bound at compile time while intent-based calls are run-time bound (mostly)

It is these two differences that take Android platform to a different league.

NOTE: Intents can be made to work exactly like API calls by using what are called explicit intents, which will be explained later. But more often than not, implicit intents are the way to go and that is what is explained here.

One component that wants to invoke another has to only express its' "intent" to do a job. And any other component that exists and has claimed that it can do such a job through "intent-filters", is invoked by the android platform to accomplish the job. This means, both the components are not aware of each other's existence and can still work together to give the desired result for the end-user.

This dotted line connection between components is achieved through the combination of intents, intent-filters and the android platform.

This leads to huge possibilities like:

1. Mix and match or rather plug and play of components at runtime

2. Replacing the inbuilt android applications with custom developed applications

3. Component level reuse within and across applications

4. Service orientation to the most granular level, if I may say

Now that the concept of intent has been introduced, let me get down to a more formal definition of Intent.

Intent is a bundle of information, a passive data structure that holds an abstract description of the operation to be performed. (or in the case of broadcasts, a description of an event that has happened and is being announced).

There are 2 types of intents which I intend to detail in the next part of this series. Before winding up part 1, I would finally also give you a formal definition of Intent filters.

Intent filters are the means through which a component advertizes its own capabilities to handle specific job/operations to the android platform.

Tips for High Performance Websites

Steve Souders in his website has given 15 tips - some very fundamental ones for creating high performance websites, along with demonstrations of what he says. Very Interesting and useful.

The list is here. Visit his website to actually see the demos.

• Rule 1 - Make Fewer HTTP Requests
• Rule 2 - Use a Content Delivery Network
• Rule 3 - Add an Expires Header
• Rule 4 - Gzip Components
• Rule 5 - Put Stylesheets at the Top
• Rule 6 - Put Scripts at the Bottom
• Rule 7 - Avoid CSS Expressions
• Rule 8 - Make JavaScript and CSS External
• Rule 9 - Reduce DNS Lookups
• Rule 10 - Minify JavaScript
• Rule 11 - Avoid Redirects
• Rule 12 - Remove Duplicate Scripts
• Rule 13 - Configure ETags
• Rule 14 - Make AJAX Cacheable
• Rule 15 - Use Iframes Wisely

He even talks about tools that he has used for some of these tasks, ex. JSmin to minify a script, Dojo compressor to obfuscate a script, etc.

Interestingly he also points that most of the optimization for better performing websites seems to be a front end problem more than a back end one. He has learnt this when he was the chief performance Yahoo! and has published a book "High Performance Web Sites: Essential Knowledge for Front-End Engineers " on the same.