Friday, April 30, 2010

IPL 2010 Final Mumbai Indians Vs Chennai Super Kings

IPL 2010 Final MATCH60 - MI vs CSK

Full Match


READ MORE - IPL 2010 Final Mumbai Indians Vs Chennai Super Kings

A simple RSS reader, in ListView

In the last exercise, "A simple RSS reader, using Android's org.xml.sax package", the RSS's titles are displayed as a single String. For sure it's not a good presentation in this way.

In this article, it will be modified to display it in ListView.

AndroidManifest.xml to grant "android.permission.INTERNET" to the application. (Refer to last article "A simple RSS reader, using Android's org.xml.sax package")

In order to use ListView, create a new file, /res/layout/rsslist.xml
<?xml version="1.0" encoding="utf-8"?>
android:textSize="10sp" />

Modify main.xml to have a ListView
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android=""
android:text="@string/hello" />
android:layout_height="wrap_content" />
android:text="No Data" />

package com.exercise.AndroidRssReader;

import java.util.ArrayList;
import java.util.List;

import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;

import org.xml.sax.Attributes;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.XMLReader;
import org.xml.sax.helpers.DefaultHandler;

import android.os.Bundle;
import android.widget.ArrayAdapter;

public class AndroidRssReader extends ListActivity {

private List<String> item = new ArrayList<String>();

/** Called when the activity is first created. */
public void onCreate(Bundle savedInstanceState) {

try {
URL rssUrl = new URL("");
SAXParserFactory mySAXParserFactory = SAXParserFactory.newInstance();
SAXParser mySAXParser = mySAXParserFactory.newSAXParser();
XMLReader myXMLReader = mySAXParser.getXMLReader();
RSSHandler myRSSHandler = new RSSHandler();
InputSource myInputSource = new InputSource(rssUrl.openStream());

} catch (MalformedURLException e) {
// TODO Auto-generated catch block
} catch (ParserConfigurationException e) {
// TODO Auto-generated catch block
} catch (SAXException e) {
// TODO Auto-generated catch block
} catch (IOException e) {
// TODO Auto-generated catch block

ArrayAdapter<String> itemList = new ArrayAdapter<String>(this, R.layout.rsslist, item);

private class RSSHandler extends DefaultHandler
final int stateUnknown = 0;
final int stateTitle = 1;
int state = stateUnknown;

public void startDocument() throws SAXException {
// TODO Auto-generated method stub

public void endDocument() throws SAXException {
// TODO Auto-generated method stub

public void startElement(String uri, String localName, String qName,
Attributes attributes) throws SAXException {
// TODO Auto-generated method stub
if (localName.equalsIgnoreCase("title"))
state = stateTitle;
state = stateUnknown;

public void endElement(String uri, String localName, String qName)
throws SAXException {
// TODO Auto-generated method stub
state = stateUnknown;

public void characters(char[] ch, int start, int length)
throws SAXException {
// TODO Auto-generated method stub
String strCharacters = new String(ch, start, length);
if (state == stateTitle)



Download the files.

READ MORE - A simple RSS reader, in ListView

Wednesday, April 28, 2010

Multitasking the Android Way

[This post is by Dianne Hackborn, a Software Engineer who sits very near the exact center of everything Android. — Tim Bray]

Android is fairly unique in the ways it allows multiple applications to run at the same time. Developers coming from a different platform may find the way it operates surprising. Understanding its behavior is important for designing applications that will work well and integrate seamlessly with the rest of the Android platform. This article covers the reasons for Android's multitasking design, its impact on how applications work, and how you can best take advantage of Android's unique features.

Design considerations

Mobile devices have technical limitations and user experience requirements not present in desktop or web systems. Here are the four key constraints we were working under as we designed Android's multitasking:

  • We did not want to require that users close applications when "done" with them. Such a usage pattern does not work well in a mobile environment, where usage tends to involve repeated brief contact with a wide variety of applications throughout the day.

  • Mobile devices don't have the luxury of swap space, so have fairly hard limits on memory use. Robert Love has a very good article covering the topic.

  • Application switching on a mobile device is extremely critical; we target significantly less than 1 second to launch a new application. This is especially important when the user is switching between a few applications, such as switching to look at a new SMS message while watching a video, and then returning to that video. A noticeable wait in such situations will quickly make users hate you.

  • The available APIs must be sufficient for writing the built-in Google applications, as part of our "all applications are created equal" philosophy. This means background music playback, data syncing, GPS navigation, and application downloading must be implemented with the same APIs that are available to third party developers.

The first two requirements highlight an interesting conflict. We don't want users to worry about closing their apps, but rather make it appear that all of the applications are always running. At the same time, mobile devices have hard limits on memory use, so that a system will degrade or even start failing very quickly as it needs more RAM than is available; a desktop computer, with swap, in contrast will simply start slowing down as it needs to page RAM to its swap space. These competing constraints were a key motivation for Android's design.

When does an application "stop"?

A common misunderstanding about Android multitasking is the difference between a process and an application. In Android these are not tightly coupled entities: applications may seem present to the user without an actual process currently running the app; multiple applications may share processes, or one application may make use of multiple processes depending on its needs; the process(es) of an application may be kept around by Android even when that application is not actively doing something.

The fact that you can see an application's process "running" does not mean the application is running or doing anything. It may simply be there because Android needed it at some point, and has decided that it would be best to keep it around in case it needs it again. Likewise, you may leave an application for a little bit and return to it from where you left off, and during that time Android may have needed to get rid of the process for other things.

A key to how Android handles applications in this way is that processes don't shut down cleanly. When the user leaves an application, its process is kept around in the background, allowing it to continue working (for example downloading web pages) if needed, and come immediately to the foreground if the user returns to it. If a device never runs out of memory, then Android will keep all of these processes around, truly leaving all applications "running" all of the time.

Of course, there is a limited amount of memory, and to accommodate this Android must decide when to get rid of processes that are not needed. This leads to Android's process lifecycle, the rules it uses to decide how important each process is and thus the next one that should be dropped. These rules are based on both how important a process is for the user's current experience, as well as how long it has been since the process was last needed by the user.

Once Android determines that it needs to remove a process, it does this brutally, simply force-killing it. The kernel can then immediately reclaim all resources needed by the process, without relying on that application being well written and responsive to a polite request to exit. Allowing the kernel to immediately reclaim application resources makes it a lot easier to avoid serious out of memory situations.

If a user later returns to an application that's been killed, Android needs a way to re-launch it in the same state as it was last seen, to preserve the "all applications are running all of the time" experience. This is done by keeping track of the parts of the application the user is aware of (the Activities), and re-starting them with information about the last state they were seen in. This last state is generated each time the user leaves that part of the application, not when it is killed, so that the kernel can later freely kill it without depending on the application to respond correctly at that point.

In some ways, Android's process management can be seen as a form of swap space: application processes represent a certain amount of in-use memory; when memory is low, some processes can be killed (swapped out); when those processes are needed again, they can be re-started from their last saved state (swapped in).

Explicitly running in the background

So far, we have a way for applications to implicitly do work in the background, as long as the process doesn't get killed by Android as part of its regular memory management. This is fine for things like loading web pages in the background, but what about features with harder requirements? Background music playback, data synchronization, location tracking, alarm clocks, etc.

For these tasks, the application needs a way to tell Android "I would explicitly like to run at this point." There are two main facilities available to applications for this, represented by two kinds of components they can publish in their manifest: broadcast receivers and services.

Broadcast Receivers

A BroadcastReceiver allows an application to run, for a brief amount of time, in the background as a result of something else happening. It can be used in many ways to build higher-level facilities: for example the AlarmManager allows an application to have a broadcast sent at a certain time in the future, and the LocationManager can send a broadcast when it detects interesting changes in location. Because information about the receiver is part of an application's manifest, Android can find and launch the application even if it isn't running; of course if it already has its process available in the background, the broadcast can very efficiently be directly dispatched to it.

When handling a broadcast, the application is given a fixed set of time (currently 10 seconds) in which to do its work. If it doesn't complete in that time, the application is considered to be misbehaving, and its process immediately tossed into the background state to be killed for memory if needed.

Broadcast receivers are great for doing small pieces of work in response to an external stimulus, such as posting a notification to the user after being sent a new GPS location report. They are very lightweight, since the application's process only needs to be around while actively receiving the broadcast. Because they are active for a deterministic amount of time, fairly strong guarantees can be made about not killing their process while running. However they are not appropriate for anything of indeterminate length, such as networking.


A Service allows an application to implement longer-running background operations. There are actually a lot of other functions that services provide, but for the discussion here their fundamental purpose is for an application to say "hey I would like to continue running even while in the background, until I say I am done." An application controls when its service runs by explicitly starting and stopping the service.

While services do provide a rich client-server model, its use is optional. Upon starting an application's services, Android simply instantiates the component in the application's process to provide its context. How it is used after that is up to the application: it can put all of the needed code inside of the service itself without interacting with other parts of the application, make calls on other singleton objects shared with other parts of the app, directly retrieve the Service instance from elsewhere if needed, or run it in another process and do a full-blown RPC protocol if that is desired.

Process management for services is different than broadcast receivers, because an unbounded number of services can ask to be running for an unknown amount of time. There may not be enough RAM to have all of the requesting services run, so as a result no strong guarantees are made about being able to keep them running.

If there is too little RAM, processes hosting services will be immediately killed like background processes are. However, if appropriate, Android will remember that these services wish to remain running, and restart their process at a later time when more RAM is available. For example, if the user goes to a web page that requires large amounts of RAM, Android may kill background service processes like sync until the browser's memory needs go down.

Services can further negotiate this behavior by requesting they be considered "foreground." This places the service in a "please don't kill" state, but requires that it include a notification to the user about it actively running. This is useful for services such as background music playback or car navigation, which the user is actively aware of; when you're playing music and using the browser, you can always see the music-playing glyph in the status bar. Android won't try to kill these services, but as a trade-off, ensures the user knows about them and is able to explicitly stop them when desired.

The value of generic components

Android's generic broadcast receiver and service components allow developers to create a wide variety of efficient background operations, including things that were never originally considered. In Android 1.0 they were used to implement nearly all of the background behavior that the built-in and proprietary Google apps provided:

  • Music playback runs in a service to allow it to continue operating after the user leaves the music application.

  • The alarm clock schedules a broadcast receiver with the alarm manager, to go off at the next set alarm time.

  • The calendar application likewise schedules an alarm to display or update its notification at the appropriate time for the next calendar event.

  • Background file download is implemented a service that runs when there are any downloads to process.

  • The e-mail application schedules an alarm to wake up a service at regular intervals that looks for and retrieves any new mail.

  • The Google applications maintain a service to receive push notifications from the network; it in turn sends broadcasts to individual apps when it is told that they need to do things like synchronize contacts.

As the platform has evolved, these same basic components have been used to implement many of the major new developer features:

  • Input methods are implemented by developers as a Service component that Android manages and works with to display as the current IME.

  • Application widgets are broadcast receivers that Android sends broadcasts to when it needs to interact with them. This allows app widgets to be quite lightweight, by not needing their application's process remain running.

  • Accessibility features are implemented as services that Android keeps running while in use and sends appropriate information to about user interactions.

  • Sync adapters introduced in Android 2.0 are services that are run in the background when a particular data sync needs to be performed.

  • Live wallpapers are a service started by Android when selected by the user.

READ MORE - Multitasking the Android Way

More Blogginess

Hello everyone, and welcome to a rare (in this space) blog about blogging. My name is Tim Bray, and I’m the new editor of this Android Developers’ Blog. I am only a student of Android, but I’m a veteran blogger, I’m part of the Android team, and they’ve given me a pretty free hand to find and publish the interesting stories. I’m expecting to enjoy this and hope you will too.

The work on Android is done at various places around the world, but in Mountain View, California there’s a building on the Google campus with an Android statue in front of it, positioned among dessert-themed sculptures that illustrate the major platform releases to date.

As of now, this blog has a header image taken from where some of the Android work happens, behind the statuary looking out. There are a ton of places on the Internet where you can read people’s opinions about what’s happening next with Android, and a lot of them are good. The one you’re reading now is the one that’s written from the inside looking out.


This space has been used mostly in a just-the-facts press-release-flavored way and, while that’s been useful, I thought it could be livelier. Because, even after only a few weeks’ exposure to what’s going on here, I’ve discovered that there are a ton of interesting Android stories, and while some of them probably have to be secrets, there are more than enough we can tell to crank up the interest level here.

I offered this opinion internally, loudly and repeatedly, and Android management surprised me by coming back with “OK, it’s your problem now.”


I’m not going to write everything here; I’m going to track down the people who actually do the creative Android-building work and get them to tell their own stories. I will bend over backward to make sure the articles have the voices of the people who write them.

We will go on being a source for hard opinion-free just-the-facts Android news. But I’d like to surround each burst of that with a cluster of reportage about what it means and how we think it will affect the Android communities.

The immediate future is going to be pretty intense, because we’re only a few weeks away from Google I/O, and I don’t think that I’m telling any secrets when I say that there will be Android-related announcements at that event. So the problems that come with the new job probably won’t include scaring up content.

The first new-flavor post is going to be on a currently-hot subject, multitasking and background processing, written by an engineer at the center of the Android universe.

Wish me luck, and stay tuned!

READ MORE - More Blogginess

Desktop Wallpaper Hd 1080p
Info Wallpapers: hd wallpaper 1080p
High resolution nature wallpapers - Free HD nature wallpapers
New HD Wallpapers: Full HD 1080p Quality Desktop Wallpapers Free ...
images of 1080p full hd wallpapers & backgrounds desktop 5 8 wallpaper
Wallpapers HD 1080P HD Desktop Wallpaper and Best Backgrounds for your ...
... of 1080p gzel hd manzara resimleri most desktop wallpapers wallpaper
Black tea roses Wallpaper, HD 1080p | HD Desktop Wallpapers
love quotes: desktop hd wallpapers 1080p
images of art funny hd wallpapers 1080p wallpaper
John Daly Wallpaper Page 27 Images
images of download free 1080p flower hd wallpapers 02 36 wallpaper
Desktop Wallpapers Hd 1080p
... 1080p hd wallpapers 1080p HD Wallpapers & Backgrounds,Desktop 6 14
... hd wallpapers 1080p taken Google HD Wallpapers & Backgrounds,Desktop 5
... HD 1080p Wallpapers HD Wallpapers & Backgrounds,Desktop 5 30 2013 7 59
HD Desktop Wallpapers, HD GIRLS WALLPAPERS 1080P, Hot Black Girl Sport ...
wallpaper hd 1080p wallpapers backgrounds nature wallpaper hd 1080p ...
nature wallpapers hd 1080p. nature wallpapers hd 1080p.
images of high definition wallpapers hd wallpaper
... hd wallpapers 1080p full hd desktop mac mac wallpaper 1080p apple
definition hd quality desktop wallpapers for your normal hd 720p 1080p ...
Nature HD Desktop Wallpapers 1080p | HD WALLPAPERS
HD Wallpapers: widescreen hd wallpapers 1080p
... of 1080p gzel hd manzara resimleri most desktop wallpapers wallpaper
love quotes: desktop hd wallpapers 1080p
hd desktop wallpaper 1080p -
Blu Ray | Wallpapers 2012|1080p |1920x1080 wallpapers | HD wallpapers ...
hd desktop wallpaper 1080p -
Desktop Hd Wallpaper |
Full HD Wallpapers 1080p HD Mixed | HD Wallpapers 1080p
New HD Wallpapers: Beautiful Beach HD(1080p) Wallpapers For Desktop ...
... | We love this wallpaper HD wallpapers - 1080p desktop ... - Do It
... Birthday Wishes Hd Wallpaper 1080p World Wallpapers -
... Wallpapers Full HD 1080p HD Wallpapers & Backgrounds,Desktop 6 9 2013
Blu Ray | Wallpapers 2012|1080p |1920x1080 wallpapers | HD wallpapers ...
Hd 1080p Wallpaper, Desktop HD Wallpapers, Nature 1080p HD Wallpaper ...
... Free Wallpapers Backgrounds - car wallpapers 1920 x 1080 1080p Full HD
Full HD Wallpapers 1080p HD Nature Wallpaper | HD Wallpapers 1080p
25 Natural Desktop HD 1080p Wallpapers | Boss Wallpapers
hd desktop wallpaper 1080p -
Pin Skrillex Desktop 1920x1080 Wallpaper 1047348jpg on Pinterest
Desktop Backgrounds Super Hd Nature 1440x900px Nature Hd Wallpapers ...
... Ola Fondos De Pantalla Windows 7 Logotipo De La | Free HD Wallpapers
Wallpaper Chica Gsxr De Fastbikes Motos Suzuki Gsx R | Free HD ...
Hi-Def Static \\\"G Scale Train\\\" Derailment At The End
Images Of Scene Hairstyles For Girls With Glasses 6 Wallpaper
... For Today S Update We Have Great Wallpaper With | Free HD Wallpapers
Assassin's Creed , Uplay logo , Ubisoft, and the Ubisoft logo are ...
Lamborghini aventador matte black / Lamborghini Diablo - Specs, Videos ...
Suzuki Hayabusa Predator bike Super cool tuning|Girls, cars and bikes
... Fondos De Escritorios 3d Taringa Re Downloadscom | Free HD Wallpapers
... Kaka Background Ricardo Kaka High Definition | Free HD Wallpapers
... Combate De La Historia F 35 Lightning I Taringa | Free HD Wallpapers
... Habra Entonces Denle Click Derecho Y Guarden La | Free HD Wallpapers
Random Facts And Myths Fun Valentines Day Facts | Love Wallpapers HD
... De Escritorio Fondos De Escritorio El Facebook | Free HD Wallpapers
Wallpapers Hd Psy -
Explanations Of My Wallpapers (the Dates After Them Are The Dates ...
zelda #wallpapers. Loading... Hide notes

READ MORE - Desktop Wallpaper Hd 1080p
Related Posts Plugin for WordPress, Blogger...