Thankfully, a brilliant Android engineer named Michael Portuesi came to my aid and helped me sort out the missing pieces, and I decided to create an example Robolectric project to share his wisdom and help other people get started. This project also includes an Ant script that you can easily plug into Jenkins or any other Ant-based CI process.

How does it work?

A Robolectric test project requires dependencies on:

• android.jar
• maps.jar
• junit.jar
• hamcrest.jar
• robolectric-with-dependencies.jar
• The Android project being tested

There are several ways you can set this up, but for simplicity I’ve pinned these jar files into the test project’s libs folder. Some people prefer linking the Robolectric source into their test projects, so they can modify the Robolectric code as necessary. You can also use environment variables in place of the Maps and Android jars, and add references to JUnit and Hamcrest to your test project’s build path via Eclipse.

After cloning this repository, add the android-project and android-project-test projects into an Eclipse workspace. The android-project is an Android project (obviously), and the android-project-test project is a plain old Java project. You should be able to right-click on the android-project-test project, and choose “Run As -> JUnit Test”, and the single test should run via Robolectric and JUnit. Alternatively, you should be able to right-click on the build.xml file and choose “Run As -> Ant Build”. This ant script can be used to run your Robolectric tests via a CI server like Jenkins.

Take note of SampleTestRunner.java. This class inherits from RobolectricTestRunner, and tells Robolectric how to resolve references to your Android project’s manifest and resources:

package com.justinschultz.tests.runner;

import java.io.File;

import org.junit.runners.model.InitializationError;

import com.xtremelabs.robolectric.RobolectricConfig;
import com.xtremelabs.robolectric.RobolectricTestRunner;

public class SampleTestRunner extends RobolectricTestRunner {
	/**
	 * Call this constructor to specify the location of resources and AndroidManifest.xml.
	 *
	 * @param testClass
	 * @throws InitializationError
	 */
	public SampleTestRunner(@SuppressWarnings("rawtypes") Class testClass) throws InitializationError {
		super(testClass, new RobolectricConfig(new File("../android-project/AndroidManifest.xml"), new File("../android-project/res")));
	}
}

When authoring tests, make sure your class names end with the word “Test”, as the ant script requires this. Also make sure that their @RunWith annotations use the SampleTestRunner.class, and NOT the RobolectricTestRunner.class:

@RunWith(SampleTestRunner.class)
public class SampleTest {
    @Test
    public void testBasicResourceValue() throws Exception {
        String helloFromActivity = new MainActivity().getResources().getString(R.string.hello);
        assertThat(helloFromActivity, equalTo("Hello World, MainActivity!"));
    }
}

Finally, make sure junit.jar is defined in your Ant script’s classpath BEFORE android.jar, otherwise Ant will throw an error:

	<path id="junit_classpath">
		<pathelement path="${build.dir}"/>
		<pathelement path="${android.project.classpath}"/>
		<!-- NOTE: junit.jar must come before android.jar! -->
		<filelist refid="libs_jars"/>
		<filelist refid="android_jars"/>
	</path>

And that’s it. You should be able to clone the Android Eclipse Robolectric Example from GitHub and immediately run the sample test via Ant or JUnit in Eclipse.

This is something that’s not technically difficult to do, but it’s not documented very well.

Here’s how to do it:

1. Write a class that inherits from MapView, and add a GestureDetector to the child class. Then, override the onTouchEvent(MotionEvent event) method and pass the MotionEvent along to your GestureDetector:

package com.justinschultz.android.controls;

import android.content.Context;
import android.util.AttributeSet;
import android.view.GestureDetector;
import android.view.GestureDetector.OnDoubleTapListener;
import android.view.MotionEvent;
import android.view.GestureDetector.OnGestureListener;
import com.google.android.maps.MapView;

public class MyMapView extends MapView
{
	private GestureDetector gestureDetector;

	public MyMapView(Context context, AttributeSet attrs)
	{
		super(context, attrs);

		gestureDetector = new GestureDetector((OnGestureListener) context);
		gestureDetector.setOnDoubleTapListener((OnDoubleTapListener) context);
	}

    @Override
	public boolean onTouchEvent(MotionEvent ev)
	{
		return this.gestureDetector.onTouchEvent(ev);
	}
}

2. Refer to this child class in your layout XML file, instead of the regular MapView:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
	android:layout_width="fill_parent" android:layout_height="fill_parent">
	<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
	    android:orientation="vertical"
	    android:layout_width="fill_parent"
	    android:layout_height="wrap_content">

		<com.justinschultz.android.controls.MyMapView
	    xmlns:android="http://schemas.android.com/apk/res/android"
	    android:id="@+id/mapview"
	    android:layout_width="fill_parent"
	    android:layout_height="wrap_content"
	    android:clickable="true"
	    android:apiKey="YOUR_API_KEY" />

	</RelativeLayout>
</LinearLayout>

3. Implement the OnGestureListener and OnDoubleTapListener interfaces in your MapActivity class, and write some code to zoom-in the map in the onDoubleTap(MotionEvent e) method:

public class Map extends MapActivity
    implements OnGestureListener, OnDoubleTapListener {
 // More map stuff here, and additional forced overrides from the interfaces
 @Override
 public boolean onDoubleTap(MotionEvent e) {
      // Assuming your MapView is called mapView
     mapView.getController().zoomIn();
     return true;
 }

And that’s it! Your map will now zoom-in when the user double-taps.

To launch hierarchyviewer, simply open a terminal or command window and type hierarchyviewer. To open hierarchyviewer via Eclipse, select Window -> Open Perspective -> Hierarchy View.

For security reasons you can’t run it on-device, so you’ll need to have an application running on an emulator. Also, make sure Eclipse isn’t trying to debug your application when using HierarchyViewer or it won’t work.

As its name suggests, HierarchyViewer will present you with a hierarchy of the view objects for the layout you select. After you’ve launched the tool, select the Activity you’d like to profile and click the button labeled “Load View Hierarchy.” For my simple demo, the hierarchy looks like this:

Hierarchy Viewer

UI Performance

In addition to providing information about the view hierarchy, the HierarchyViewer tool also provides 3 important metrics about the rendering performance for each View object on the selected Layout’s UI:

• The time it takes to Measure
• The time it takes to Layout
• The time it takes to Draw

Here’s a great Google IO presentation on using hierarchyviewer, and understanding these metrics:

To make matters worse, Google prevents you from using the Android SDK if it’s not running on a device or emulator. If you do, you’ll be thwarted by a RuntimeException and message:

java.lang.RuntimeException: Stub!

Pivotal Labs’ Robolectric is a unit test framework that de-couples the Android SDK jar so you can test-drive the development of your Android app. Tests run inside the JVM on your workstation in seconds.

With Robolectric, you can write tests like this:

// Test class for MyActivity
@RunWith(RobolectricTestRunner.class)
public class MyActivityTest {
    private Activity activity;
    private Button pressMeButton;
    private TextView results;

    @Before
    public void setUp() throws Exception {
        activity = new MyActivity();
        activity.onCreate(null);
        pressMeButton = (Button) activity.findViewById(R.id.press_me_button);
        results = (TextView) activity.findViewById(R.id.results_text_view);
    }

    @Test
    public void shouldUpdateResultsWhenButtonIsClicked() throws Exception {
        pressMeButton.performClick();
        String resultsText = results.getText().toString();
        assertThat(resultsText, equalTo("Robolectric Rules."));
    }
}

Robolectric makes this possible by intercepting the loading of the Android classes and rewriting the method bodies. Robolectric re-defines Android methods so they return null (or 0, false, etc.), or if provided Robolectric will forward method calls to shadow Android objects giving the Android SDK behavior. Robolectric provides a large number of shadow objects covering much of what a typical application would need to test-drive the business logic and functionality of your application. Coverage of the SDK is improving every day.

Resource Support

Robolectric handles inflation of views, string resource lookups, etc. Some view attributes (id, visibility enabled, text, checked, and src) are parsed and applied to inflated views. Activity and View #findViewById() methods return Android view objects. Support exists for include and merge tags. These features allow tests access resources and to assert on view state.

Run Tests Outside of the Emulator

Run your tests on your workstation, or on your Continuous Integration environment. Because tests run on your workstation in a JVM and not in the emulator Android runtime, the dexing, packaging, and installation on the emulator steps are not necessary, allowing you to iterate quickly and refactor your code with confidence.

Here is a link with step-by-step instructions on getting Robolectric set up in Eclipse.

Potential Robolectric Pitfalls

I ran into a few issues using Robolectric at Breezy:

• Robolectric doesn’t support all Android SDK APIs
• Running Robolectric in a team environment is difficult without something like Maven. Eclipse doesn’t allow you to set relative directory paths for libraries by default, so if your Robolectric, Android SDK, and JUnit libraries live in different paths on different developer’s machines, you’ll have a tough time sharing a configured test project.
• Robolectric caches its shadow classes, which can produce unexpected test results. Here’s a blog post about mitigating this.

Despite these few nuances, I love Robolectric. Here’s a great how-to video on Robolectric by Pivotal Labs, and here’s a link to the Robolectric Google Group if you run into problems.

Performing long-running operations such as network access or database queries on this thread will block the user interface, and eventually crash your application with an Application Not Responding (ANR) error.

In this tutorial I’ll show you a simple way to perform a long-running task in the background using the AsyncTask class to download an image.

To start, create a new application and update the main.xml layout file with this:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:orientation="vertical" >

    <Button
        android:id="@+id/btnDownloadImages"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:layout_below="@+id/helloText"
        android:onClick="downloadImage"
        android:text="Tap to Download Image" />

    <ImageView
        android:id="@+id/imgDownload"
        android:layout_width="fill_parent"
        android:layout_height="fill_parent"
        android:layout_below="@+id/helloText" />

</LinearLayout>

When a user taps the button, we’ll:

1. Display a busy dialog
2. Invoke an AsyncTask to download an image from the internet
3. Display the downloaded image in the ImageView control
4. Hide the busy dialog

Here’s the Activity class to achieve this (note the comments):

package com.justinschultz.asynctaskexample;

import java.io.InputStream;
import java.net.URL;

import android.app.Activity;
import android.app.ProgressDialog;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.AsyncTask;
import android.os.Bundle;
import android.view.View;
import android.widget.ImageView;

public class AsyncTaskExampleActivity extends Activity {
	ImageView _imgView = null;
	ProgressDialog _busyDialog = null;

	/** Called when the activity is first created. */
	@Override
	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.main);
		// Need an Activity-level reference to the ImageView
		_imgView = (ImageView) findViewById(R.id.imgDownload);
	}

	public void downloadImage(View v) {
		// Need to show the busy dialog here, since we can't do it in
		// DownloadImageTask's doInBackground() method
		showBusyDialog();
		new DownloadImageTask()
				.execute("http://code.google.com/android/goodies/wallpaper/android-wallpaper5_1024x768.jpg");
	}

	private class DownloadImageTask extends AsyncTask<String, Void, Bitmap> {
		@Override
		protected Bitmap doInBackground(String... url) {
			// You might be tempted to display the busy dialog here, but you
			// CAN'T update the UI from this method!
			return loadImageFromNetwork(url[0]);
		}

		@Override
		protected void onPostExecute(Bitmap result) {
			// Our long-running process is done, and we can safely access the UI thread
			dismissBusyDialog();
			_imgView.setImageBitmap(result);
		}
	}

	private Bitmap loadImageFromNetwork(String url) {
		Bitmap bitmap = null;

		try {
			bitmap = BitmapFactory.decodeStream((InputStream) new URL(url).getContent());
		} catch (Exception e) {
			e.printStackTrace();
		}

		return bitmap;
	}

	public void showBusyDialog() {
		_busyDialog = ProgressDialog.show(this, "", "Downloading Image...", true);
	}

	public void dismissBusyDialog() {
		if (_busyDialog != null) {
			_busyDialog.dismiss();
		}
	}
}

The AsyncTask class must be subclassed, and it’s 3 generic types are:

1. Params: the type of the parameters sent to the task upon execution.
2. Progress: the type of the progress units published during the background computation.
3. Result: the type of the result of the background computation.

Not all types are always used by an asynchronous task. To mark a type as unused, simply use the type Void:

private class MyTask extends AsyncTask<Void, Void, Void> { ... }

I don’t recommend using AsyncTask for things like long-running API calls, but it’s fine for short tasks within the activity life (between onResume and onPause). I’ll cover approaches to long-running API calls in a future post.

Download the complete code for this example here.

Examples Pusher applications:

• Updating a website or mobile application with sports scores or stock prices in real-time
• Sending real-time messages to Arduino devices from a web or mobile application
• Building a real-time donation thermometer on a website
• Tracking multi-player game moves… in real-time
• You get the idea…

I recently used Pusher at Breezy to notify user’s printers when documents sent from their mobile devices are ready to be printed. It’s very fast (real-time!) and powerful stuff, and I immediately started thinking about ways to implement it in Android applications.

Surprisingly, nobody had built a full-featured Java / Android client for Pusher, so I decided to build one.

Pusher is event-driven, so the first thing to do is create an event listener:

PusherListener eventListener = new PusherListener() {
	@Override
	public void onConnect(String socketId) {
		System.out.println("Pusher connected. Socket Id is: " + socketId);
	}

	@Override
	public void onMessage(String message) {
		System.out.println("Received message from Pusher: " + message);
	}

	@Override
	public void onDisconnect() {
		System.out.println("Pusher disconnected.");
	}
};

Next, create an instance of the Pusher class and pass it the API key you were assigned while signing up for Pusher. Then set the event listener from the previous step and connect:

Pusher pusher = new Pusher(YOUR_API_KEY);
pusher.setPusherListener(eventListener);
pusher.connect();

Pusher’s communication happens over public, private or presence Channels, and you can bind to or trigger events on any of these channel types:

// Public Channel
channel = pusher.subscribe(PUSHER_CHANNEL);
// Private Channel
channel = pusher.subscribe(PUSHER_CHANNEL, AUTH_TOKEN);
// Presence Channel
channel = pusher.subscribe(PUSHER_CHANNEL, AUTH_TOKEN, USER_ID);
// Trigger an event
channel.send("trigger-event", new JSONObject());
// Bind to the "price-updated" event with a ChannelListener
channel.bind("price-updated", new ChannelListener() {
  @Override
  public void onMessage(String message) {
    System.out.println("Received bound channel message: " + message);
  }
});

The Java / Android Pusher library can be found on GitHub here.

Please let me know if you have any feedback or questions.

In this tutorial, I’ll illustrate a memory leak with a simple dialog box example, and then show you how to fix it.

Let’s start by creating a simple Android application that displays a dialog in its onCreate event:

package com.justinschultz.android;

import android.app.Activity;
import android.app.AlertDialog;
import android.content.DialogInterface;
import android.os.Bundle;

public class LeakedDialogActivity extends Activity {

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

		AlertDialog.Builder builder = new AlertDialog.Builder(this);
		builder.setIcon(android.R.drawable.ic_dialog_alert);
		builder.setMessage("This dialog leaks!").setTitle("Leaky Dialog").setCancelable(false).setPositiveButton("Ok", new DialogInterface.OnClickListener()
		{
			public void onClick(DialogInterface dialog, int which) {}
		});

		AlertDialog alert = builder.create();
		alert.show();
    }
}

If you’ve copied this correctly, the app should look like this:

Leaky Android Dialog

While this application is running, take a look in LogCat. (In Eclipse, LogCat can be displayed via Window -> Show View -> LogCat.)

While the dialog is displayed, rotate the device (or the emulator by pressing CTRL+F11).

You should see a lot of bright red error text in LogCat that looks something like this:

LogCat Leaked Window Error

Activity com.justinschultz.android.LeakedDialogActivity has leaked
window com.android.internal.policy.impl.PhoneWindow$DecorView@40543ec0
that was originally added here

So… what happened?

When the device rotates, the onPause and onStop Activity events are invoked. Then a new landscape Activity is created, and its onCreate method is invoked.

Since the dialog is displayed and has a reference to the Activity, it can’t be garbage collected, and subsequently is leaked. That is, you’ve created an object that can’t be garbage collected.

To fix this, let’s make the dialog an Activity member variable and override the onPause method to dismiss it:

  AlertDialog _alert;

    @Override
    public void onPause() {
    	super.onPause();

    	if(_alert != null)
    		_alert.dismiss();
    }

This will dismiss the dialog each time the Activity is destroyed and recreated and the error will magically disappear from LogCat.

Here’s the source for this example.

To use it, you’ll need to create an Application class at the root of your Android application. This class will be used to log any uncaught or unhandled Exceptions, and will contain ACRA’s configuration.

Here’s a sample Application class:

package com.justinschultz.android;

import java.lang.Thread.UncaughtExceptionHandler;

import org.acra.ACRA;
import org.acra.annotation.ReportsCrashes;

import android.app.Application;
import android.util.Log;

@ReportsCrashes(formKey = "YOURFORMKEY")
public class MyApplication extends Application implements UncaughtExceptionHandler
{
	private static MyApplication instance;

	public MyApplication()
	{
		instance = this;
		Thread.setDefaultUncaughtExceptionHandler(this);
	}

	@Override
	public void onCreate()
	{
		ACRA.init(this);
		super.onCreate();
	}

	public static MyApplication getInstance()
	{
		return instance;
	}

	@Override
	public void uncaughtException(Thread thread, Throwable ex)
	{
		Log.i("Error: ", (ex == null || ex.getMessage() == null) ? "Unknown" : ex.getMessage());
	}

}

Here’s how to generate a form key and complete the configuration.

We’ll achieve this by extending BaseAdapter (or concrete ArrayAdapter) to turn a collection of objects into individual ListView items.

First, let’s define the layout for our scrollable ListView by placing the following in main.xml:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:orientation="vertical" >

    <TextView
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:gravity="center_vertical|center_horizontal"
        android:text="Custom ListView Example" />

    <ListView
        android:id="@+id/srListView"
        android:layout_width="fill_parent"
        android:layout_height="fill_parent" />

</LinearLayout>

Next, let’s define a layout for individual ListView items. Paste this layout code in a new layout file called custom_row_view.xml:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:orientation="vertical"
    android:paddingBottom="10dip"
    android:paddingLeft="10dip"
    android:paddingTop="10dip" >

    <TextView
        android:id="@+id/name"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:textColor="#C20000"
        android:textSize="14sp"
        android:textStyle="bold" />

    <TextView
        android:id="@+id/cityState"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content" />

    <TextView
        android:id="@+id/phone"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content" />

</LinearLayout>

Next, let’s create a POJO called SearchResults.java to represent contact search results. Paste this boilerplate code into it:

package com.publicstaticdroidmain.android;

public class SearchResults {
	 private String name = "";
	 private String cityState = "";
	 private String phone = "";

	 public void setName(String name) {
	  this.name = name;
	 }

	 public String getName() {
	  return name;
	 }

	 public void setCityState(String cityState) {
	  this.cityState = cityState;
	 }

	 public String getCityState() {
	  return cityState;
	 }
	 public void setPhone(String phone) {
	  this.phone = phone;
	 }

	 public String getPhone() {
	  return phone;
	 }
}

Now we need to build an Adapter. The Adapter will turn our collection of SearchResults into individual ListView items. Create a file called MyCustomBaseAdapter.java with these contents:

package com.publicstaticdroidmain.android;

import java.util.ArrayList;

import com.publicstaticdroidmain.R;

import android.content.Context;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.BaseAdapter;
import android.widget.TextView;

public class MyCustomBaseAdapter extends BaseAdapter {
	private static ArrayList<SearchResults> searchArrayList;

	private LayoutInflater mInflater;

	public MyCustomBaseAdapter(Context context, ArrayList<SearchResults> results) {
		searchArrayList = results;
		mInflater = LayoutInflater.from(context);
	}

	public int getCount() {
		return searchArrayList.size();
	}

	public Object getItem(int position) {
		return searchArrayList.get(position);
	}

	public long getItemId(int position) {
		return position;
	}

	public View getView(int position, View convertView, ViewGroup parent) {
		ViewHolder holder;
		if (convertView == null) {
			convertView = mInflater.inflate(R.layout.custom_row_view, null);
			holder = new ViewHolder();
			holder.txtName = (TextView) convertView.findViewById(R.id.name);
			holder.txtCityState = (TextView) convertView
					.findViewById(R.id.cityState);
			holder.txtPhone = (TextView) convertView.findViewById(R.id.phone);

			convertView.setTag(holder);
		} else {
			holder = (ViewHolder) convertView.getTag();
		}

		holder.txtName.setText(searchArrayList.get(position).getName());
		holder.txtCityState.setText(searchArrayList.get(position)
				.getCityState());
		holder.txtPhone.setText(searchArrayList.get(position).getPhone());

		return convertView;
	}

	static class ViewHolder {
		TextView txtName;
		TextView txtCityState;
		TextView txtPhone;
	}
}

And finally, let’s update our main Activity class (mine is called CustomListViewActivity) to tie everything together:

package com.publicstaticdroidmain.android;

import java.util.ArrayList;

import com.publicstaticdroidmain.R;

import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.ListView;
import android.widget.Toast;

public class CustomListViewActivity extends Activity {
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        ArrayList<SearchResults> searchResults = GetSearchResults();

        final ListView lv = (ListView) findViewById(R.id.srListView);
        lv.setAdapter(new MyCustomBaseAdapter(this, searchResults));

        lv.setOnItemClickListener(new OnItemClickListener() {
			@Override
			public void onItemClick(AdapterView<?> a, View v, int position, long id) {
				Object o = lv.getItemAtPosition(position);
		        SearchResults fullObject = (SearchResults)o;
		        Toast.makeText(CustomListViewActivity.this, "You have chosen: " + " " + fullObject.getName(), Toast.LENGTH_LONG).show();
			}
        });
    }

    private ArrayList<SearchResults> GetSearchResults(){
     ArrayList<SearchResults> results = new ArrayList<SearchResults>();

     SearchResults sr = new SearchResults();
     sr.setName("Justin Schultz");
     sr.setCityState("San Francisco, CA");
     sr.setPhone("415-555-1234");
     results.add(sr);

     sr = new SearchResults();
     sr.setName("Jane Doe");
     sr.setCityState("Las Vegas, NV");
     sr.setPhone("702-555-1234");
     results.add(sr);

     sr = new SearchResults();
     sr.setName("Lauren Sherman");
     sr.setCityState("San Francisco, CA");
     sr.setPhone("415-555-1234");
     results.add(sr);

     sr = new SearchResults();
     sr.setName("Fred Jones");
     sr.setCityState("Minneapolis, MN");
     sr.setPhone("612-555-8214");
     results.add(sr);

     sr = new SearchResults();
     sr.setName("Bill Withers");
     sr.setCityState("Los Angeles, CA");
     sr.setPhone("424-555-8214");
     results.add(sr);

     sr = new SearchResults();
     sr.setName("Donald Fagen");
     sr.setCityState("Los Angeles, CA");
     sr.setPhone("424-555-1234");
     results.add(sr);

     sr = new SearchResults();
     sr.setName("Steve Rude");
     sr.setCityState("Oakland, CA");
     sr.setPhone("515-555-2222");
     results.add(sr);

     sr = new SearchResults();
     sr.setName("Roland Bloom");
     sr.setCityState("Chelmsford, MA");
     sr.setPhone("978-555-1111");
     results.add(sr);

     sr = new SearchResults();
     sr.setName("Sandy Baguskas");
     sr.setCityState("Chelmsford, MA");
     sr.setPhone("978-555-2222");
     results.add(sr);

     sr = new SearchResults();
     sr.setName("Scott Taylor");
     sr.setCityState("Austin, TX");
     sr.setPhone("512-555-2222");
     results.add(sr);

     return results;
    }
}

And that’s it. If you’ve done everything correctly, you should wind up with this:

Android Custom Multi-Line ListView Screenshot

Here’s the zipped source code.

./adb devices
List of devices attached
???????????? no permissions

To fix this, just run these commands from your SDK/platform-tools folder to restart the ADB server with root permissions:

./adb kill-server
sudo ./adb start-server

Now your devices should appear:

./adb devices
List of devices attached
HT09PR201016	device

Also, make sure to enable USB debugging on your device in Settings -> Applications -> Development.