The solution is rather simple, just not presented anywhere in the Android docs. We’ll create an Enum that associates the Resource IDs with our own local IDs. This way, we can store the local IDs, so that the SDK can change the resource IDs as much as it wants. Full code for the enum is at the bottom.

From now on, we retrieve resources with the Enum:

	    	 mIcon.setImageDrawable(getResources().getDrawable(ReminderResources.AUDIO_ICON.resourceId()));

Storing the ID in SQLite is also very simple, storing our ID instead of the generated one.

        initialValues.put(KEY_ICON, r.getIconID().localId());

Then, when we retrieve the ID from SQLite, we use the ‘get()’ method to retrieve the Enum:

                    reminder.setIconID(ReminderResources.get(cursor.getInt(iconColumn)));

Full code for the Enum:

public enum ReminderResources {
	AUDIO_ICON 	(0, R.drawable.audioicon),
	FORM_ICON		(1, R.drawable.form),
	FINGER_ICON 	(2, R.drawable.finger),
	LAUNDRY_ICON	(3, R.drawable.laundry),
	TASK_ICON		(4, R.drawable.task),
	BELL   		(5, R.drawable.bell);

    private final int localId;   // in kilograms
    private final int resourceId; // in meters
    ReminderResources(int localId, int resourceId) {
        this.localId = localId;
        this.resourceId = resourceId;
    }
    public int localId()   { return localId; }
    public int resourceId(){ return resourceId;}

    private static final Map<Integer,ReminderResources> lookup
    	= new HashMap<Integer,ReminderResources>();

	static {
	    for(ReminderResources s : EnumSet.allOf(ReminderResources.class))
	         lookup.put(s.localId, s);
	}

    public static ReminderResources get(int code) {
        return lookup.get(code);
   }

}

Enter Object Oriented Databases.

OODBs are great for small and simple databases, letting you write the fun(ctional) code without the drag of SQL.  We’re not talking ORM or Hibernate, with cleverly-hidden SQL.  Just simple store(MyObject) and we’re done.

The source code is found in the same place as the DataServices and SQLite project:http://svn.hat6.com/hat6public/DataServiceExample/trunk.
For all of this wonderful functionality, we’ll be using DB4O.  They even have a page dedicated to Android, though the source they provide won’t build.

The code matches the DataService interface I provided earlier, so if you’ve read through the SQLite post, you should be able to scan this easily. This file weighs in at just a hair over 200 lines, and a big chunk of that is Exception handling and Comments. So, without further ado, I present to you a working DB4O Android Implementation:

package com.hat6.dataServiceExample.model;

import java.util.List;

import com.db4o.Db4o;
import com.db4o.ObjectContainer;
import com.db4o.ObjectSet;
import com.db4o.instrumentation.core.Db4oClassSource;

import android.content.Context;
import android.util.Log;

public class ReminderDB4OImpl implements IReminderDataService {

	//TAG for logging.
    private static final String TAG = "ReminderDB4OImpl";
    /**
     * Static variables holding information about our database itself.
     * NAME and TABLE are now used to determine where the DB file lives in the filesystem
     * VERSION allows our app to know if it has to perform any upgrades
     * 		(Though right now, we aren't using it)
     */
    private static final String DATABASE_NAME = "hatsixExamples";
    private static final String DATABASE_TABLE = "remindersDS";
    private static final int    DATABASE_VERSION = 1;

	/**
	 * Context is needed when interacting with the DB
	 */
	private final Context mCtx;
    /**
     * The actual Database.
     */
	private static ObjectContainer _container = null;

    /**
     * Constructor - takes the context to allow the database to be
     * opened/created
     *
     * @param ctx the Context within which to work
     */
    public ReminderDB4OImpl(Context ctx) {
		mCtx = ctx;
		open();
		Db4oClassSource dbocs; //DB40 crashes if we don't force this to be compiled in.
	}

    /**
     * Open the database. If it cannot be opened, try to create a new
     * instance of the database. If it cannot be created, throw an exception to
     * signal the failure
     *
     * @return this (self reference, allowing this to be chained in an
     *         initialization call)
     */
    public IReminderDataService open() {
		long startTime = 0;
    	try {
    		if(_container == null){
    			startTime = System.currentTimeMillis();
    			_container = Db4o.openFile(configure(), db4oDBFullPath());
    		}
    	} catch (Exception e) {
        	Log.e(TAG, e.toString());
        	return null;
        }
    	Log.d(TAG, "Database opened: " + startTime);

        return this;
    }

    public void close() {
    	if(_container != null){
    		long startTime = System.currentTimeMillis();
    		_container.close();
    		Log.d(TAG, "Database committed and closed: " + startTime);
    		_container = null;
    	}
    }

    /**
     * Create a new reminder record.  We pass in a Reminder, rather than just
     * some text values like in the Notepad Example. If the reminder is
     * successfully created return the new rowId for that reminder, otherwise return
     * a -1 to indicate failure.
     *
     * @param r the Reminder we want saved.
     * @return rowId or -1 if failed
     */
    public long createReminder(Reminder r) {
        if (_container != null){
	        try {
	        	_container.store(r);
	        	_container.commit();
	        	Log.d(TAG, "Created selected object: " + r.getTitle());

			} catch (Exception e){
				Log.d(TAG, "Reminder could not be created: " + r.getTitle());
				long l = -1;
				return l;
			}
        }
    	return r.getId();
    }

    /**
     * Fetch all Reminders.  This will utilize SQLite's cursors and create an ArrayList
     * that is passed back to the caller.
     *
     * @return List of Reminders
     */
    public List<Reminder> fetchAllReminders(){
        List<Reminder> list = _container.query(new com.db4o.query.Predicate<Reminder>() {
			private static final long serialVersionUID = 1L;
			public boolean match(Reminder r) {
        		return true;
        	}
        });
    	return list;
    }
    /**
     * Fetch Individual Reminder.  We take the 'query by example' approach, where we pass in
     * a Reminder.  DB40 truly allows us to do query by example, allowing us to search by
     * and piece of data.  We return the first result, if any.
     *
     * @param r Reminder with data set to the Reminder we want fetched.
     * @return Reminder that we were searching for, or null if not found.
     */
    public Reminder fetchReminder(Reminder r){
    	if (_container != null){
	        try {
	        	ObjectSet<Reminder> os = _container.queryByExample(r);
	        	return os.get(0);
			} catch (Exception e){
				Log.d(TAG, "Reminder not found: " + r.getTitle());
				return null;
			}
        }
    	return null;
    }
    /**
     * Update the reminder using the details provided. We pass in a
     * Reminder, create ContentValues from that Reminder, then update
     * the record based on rowID
     *
     * @param r the Reminder to update
     * @return true if the reminder was successfully updated, false otherwise
     */
    public boolean updateReminder(Reminder r) {
        if (_container != null){
	        try {
	        	_container.store(r);
	        	_container.commit();
	        	Log.d(TAG, "Updated selected object: " + r.getTitle());

			} catch (Exception e){
				Log.d(TAG, "Reminder not found: " + r.getTitle());
				return false;
			}
        }
    	return true;
    }

    /**
     * Delete the reminder.  Rather than passing in the rowID, we pass the entire
     * reminder.  Again, by passing objects, our app is significantly simplified.
     *
     * @param r the Reminder to be deleted.
     * @return true if deleted, false otherwise
     */
    public boolean deleteReminder(Reminder r) {
        if (_container != null){
	        try {
	        	_container.delete(r);
	        	_container.commit();
	        	Log.d(TAG, "Deleted selected object: " + r.getTitle());

			} catch (Exception e){
				Log.d(TAG, "Reminder not found: " + r.getTitle());
				return false;
			}
        }
    	return true;
    }

    /**
     * configure creates a new Configuration and sets some parameters, namely that
     * the 'title' should be indexed, and that the DB file should not be locked
     * @return Configuration for the OODB
     */
	private static com.db4o.config.Configuration configure(){
		com.db4o.config.Configuration configuration = Db4o.newConfiguration();
    	configuration.objectClass(Reminder.class).objectField("title").indexed(true);
    	configuration.lockDatabaseFile(false);
    	return configuration;
    }

	/**
	 * db4oDBFullPath returns the path to the DB File in the Context's path.
	 * @return String for the Database.
	 * @throws Exception
	 */
	private String db4oDBFullPath() throws Exception {
		if (mCtx == null){
			throw new Exception("Db4o Module not initialized");
		}
		return mCtx.getDir(DATABASE_NAME, Context.MODE_PRIVATE) + "/"  + DATABASE_TABLE + ".db4o";
	}

}

If you’d like to follow along in eclipse, source code is found here: http://svn.hat6.com/hat6public/DataServiceExample/trunk.

We’re only looking at one file here, ReminderSQLiteImpl.java. I’ve tried to make certain that the comments explain everything, so I’m just dumping the code below. This class comes in at about twice the size of the Notebook’s DBAdapter class, but most of that comes from my class storing more columns of data.

/**... imports removed ...**/
public class ReminderSQLiteImpl implements IReminderDataService {
	/**
	 * Static variables describing our schema.  We use these variables so that we can refer to the
	 * constants instead of having to worry about refactoring when our schema changes.
	 */
	public static final String KEY_ROWID = "_id";
    public static final String KEY_TITLE = "title";
    public static final String KEY_ICON = "icon";
    public static final String KEY_STARTDATE = "startDate";
    public static final String KEY_ENDDATE = "endDate";
    public static final String KEY_MODIFIED = "modified";
    //TAG for logging.
    private static final String TAG = "ReminderSQLiteImpl";
    /**
     * Static variables holding information about our database itself.
     * NAME and TABLE are self explanatory.
     * VERSION allows our app to know if it has to perform any upgrades (right now it's
     * 		simply dropping the entire table and all associated data).
     * CREATE allows us to specify the SQL needed to create our DB.
     */
    private static final String DATABASE_NAME = "hatsixExamples";
    private static final String DATABASE_TABLE = "remindersDS";
    private static final int    DATABASE_VERSION = 1;
    private static final String DATABASE_CREATE =
        "create table " + DATABASE_TABLE + " (" + KEY_ROWID + " INTEGER primary key autoincrement, "
                + KEY_TITLE + " TEXT not null, "
                + KEY_STARTDATE + " TEXT, "
                + KEY_ENDDATE + " TEXT, "
                + KEY_MODIFIED + " DATE not null"
                + ");";

	/**
	 * Context is needed when interacting with the DB
	 */
	private final Context mCtx;
	/**
	 * DatabaseHelper is a private class, defined at the end of this file.
	 */
    private DatabaseHelper mDbHelper;
    /**
     * The actual Database.
     */
    private SQLiteDatabase mDb;

    /**
     * Constructor - takes the context to allow the database to be
     * opened/created
     *
     * @param ctx the Context within which to work
     */
    public ReminderSQLiteImpl(Context ctx) {
		mCtx = ctx;
		open();
	}

    /**
     * Open the database. If it cannot be opened, try to create a new
     * instance of the database. If it cannot be created, throw an exception to
     * signal the failure
     *
     * @return this (self reference, allowing this to be chained in an
     *         initialization call)
     * @throws SQLException if the database could be neither opened or created
     */
    public ReminderSQLiteImpl open() throws SQLException {
        mDbHelper = new DatabaseHelper(mCtx);
        mDb = mDbHelper.getWritableDatabase();
        return this;
    }

    public void close() {
        mDbHelper.close();
    }

    /**
     * Create a new reminder record.  We pass in a Reminder, rather than just
     * some text values like in the Notepad Example. If the reminder is
     * successfully created return the new rowId for that reminder, otherwise return
     * a -1 to indicate failure.
     *
     * @param r the Reminder we want saved.
     * @return rowId or -1 if failed
     */
    public long createReminder(Reminder r) {
        ContentValues initialValues = new ContentValues();
        initialValues.put(KEY_TITLE, r.getTitle());
        initialValues.put(KEY_STARTDATE, r.getStart());
        initialValues.put(KEY_ENDDATE, r.getEnd());
        initialValues.put(KEY_MODIFIED,convertDateToString(new Date()));

        return mDb.insert(DATABASE_TABLE, null, initialValues);
    }

    /**
     * Fetch all Reminders.  This will utilize SQLite's cursors and create an ArrayList
     * that is passed back to the caller.
     *
     * @return List of Reminders
     */
    public List<Reminder> fetchAllReminders(){
    	Cursor cursor = fetchAllRemindersCursor();
        int idColumn = cursor.getColumnIndex(KEY_ROWID);
        int titleColumn = cursor.getColumnIndex(KEY_TITLE);
        int startColumn = cursor.getColumnIndex(KEY_STARTDATE);
        int endColumn = cursor.getColumnIndex(KEY_ENDDATE);

        List<Reminder> list = new ArrayList<Reminder>();
    	if(cursor != null){
            if(cursor.moveToFirst()){

                int count = cursor.getCount();
                Log.d("ReminderSqliteImpl", "there are " + count + " records.");

                for(int i=0; i<count; i++){
                    Reminder reminder = new Reminder();
                    reminder.setId(cursor.getLong(idColumn));
                    reminder.setTitle(cursor.getString(titleColumn));
                    reminder.setStart(cursor.getString(startColumn));
                    reminder.setEnd(cursor.getString(endColumn));

                    list.add(reminder);

                    cursor.moveToNext();
                }
            }
        }
    	return list;
    }
    /**
     * Fetch Individual Reminder.  We take the 'query by example' approach, where we pass in
     * a Reminder.  This would allow us to query by Title if id wasn't set.
     *
     * @param r Reminder with id set to the Reminder we want fetched.
     * @return Reminder that was passed in, with data filled out from query.
     */
    public Reminder fetchReminder(Reminder r){
    	Cursor cursor = fetchReminderCursor(r.getId());
        int idColumn = cursor.getColumnIndex(KEY_ROWID);
        int titleColumn = cursor.getColumnIndex(KEY_TITLE);
        int startColumn = cursor.getColumnIndex(KEY_STARTDATE);
        int endColumn = cursor.getColumnIndex(KEY_ENDDATE);
    	if(cursor != null){
            r.setId(cursor.getLong(idColumn));
            r.setTitle(cursor.getString(titleColumn));
            r.setStart(cursor.getString(startColumn));
            r.setEnd(cursor.getString(endColumn));
    	}
    	return r;
    }
    /**
     * Update the reminder using the details provided. We pass in a
     * Reminder, create ContentValues from that Reminder, then update
     * the record based on rowID
     *
     * @param r the Reminder to update
     * @return true if the reminder was successfully updated, false otherwise
     */
    public boolean updateReminder(Reminder r) {
        ContentValues args = new ContentValues();
        args.put(KEY_TITLE, r.getTitle());
        args.put(KEY_STARTDATE, r.getStart());
        args.put(KEY_ENDDATE, r.getEnd());
        args.put(KEY_MODIFIED,convertDateToString(new Date()));

        return mDb.update(DATABASE_TABLE, args, KEY_ROWID + "=" + r.getId(), null) > 0;
    }

    /**
     * Delete the reminder.  Rather than passing in the rowID, we pass the entire
     * reminder.  Again, by passing objects, our app is significantly simplified.
     *
     * @param r the Reminder to be deleted.
     * @return true if deleted, false otherwise
     */
    public boolean deleteReminder(Reminder r) {

        return mDb.delete(DATABASE_TABLE, KEY_ROWID + "=" + r.getId(), null) > 0;
    }

    /**
     * Return a Cursor over the list of all reminders in the database.
     * This is more of a convenience function, as we don't allow outside
     * classes to use it anymore
     *
     * @return Cursor over all reminder
     */
    private Cursor fetchAllRemindersCursor() {

        return mDb.query(DATABASE_TABLE, new String[] {
        			KEY_ROWID,
        			KEY_TITLE,
        			KEY_STARTDATE,
        			KEY_ENDDATE,
        			KEY_MODIFIED
        			}, null, null, null, null, null);
    }

    /**
     * Return a Cursor positioned at the reminder that matches the given rowId
     * Again, a convenience function, as we don't allow outside classes ot use it
     *
     * @param rowId id of reminder to retrieve
     * @return Cursor positioned to matching reminder, if found
     * @throws SQLException if reminder could not be found/retrieved
     */
    private Cursor fetchReminderCursor(long rowId) throws SQLException {

        Cursor mCursor =

                mDb.query(true, DATABASE_TABLE, new String[] {
            			KEY_ROWID,
            			KEY_TITLE,
            			KEY_STARTDATE,
            			KEY_ENDDATE,
            			KEY_MODIFIED
            			}, KEY_ROWID + "=" + rowId, null,
                        null, null, null, null);
        if (mCursor != null) {
            mCursor.moveToFirst();
        }
        return mCursor;

    }

    /**
     * convertStringToDate will take a Sqlite String and convert it to a date
     * @param s String to convert to Date
     * @return Date object
     */
	private Date convertStringToDate(String s){
		Date date = null;
		DateFormat iso8601Format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		try {
			date = iso8601Format.parse(s);
		} catch (ParseException e) {
			Log.e("Reminder.convertStringToDate", "Parsing ISO8601 datetime failed", e);
		}
		return date;
	}

	/**
	 * convertDateToString will take a Date object and return a SQLite date string
	 * @param date Date
	 * @return String
	 */
	private String convertDateToString(Date date){
		long when = date.getTime();
		int flags = 0;
		flags |= android.text.format.DateUtils.FORMAT_SHOW_TIME;
		flags |= android.text.format.DateUtils.FORMAT_SHOW_DATE;
		flags |= android.text.format.DateUtils.FORMAT_ABBREV_MONTH;
		flags |= android.text.format.DateUtils.FORMAT_SHOW_YEAR;

		String finalDateTime = android.text.format.DateUtils.formatDateTime(mCtx,
				when + TimeZone.getDefault().getOffset(when), flags);

		return finalDateTime;

	}

    /**
     * DatabaseHelper basically copied from Androids NotebookExample.
     * Here we short-circuit some functions to make our above code
     * more readable.
     */
    private static class DatabaseHelper extends SQLiteOpenHelper {

        DatabaseHelper(Context context) {
            super(context, DATABASE_NAME, null, DATABASE_VERSION);
        }

        @Override
        public void onCreate(SQLiteDatabase db) {
            db.execSQL(DATABASE_CREATE);
        }

        @Override
        public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
            Log.w(TAG, "Upgrading database from version " + oldVersion + " to "
                    + newVersion + ", which will destroy all old data");
            db.execSQL("DROP TABLE IF EXISTS " + DATABASE_NAME);
            onCreate(db);
        }
    }

}

Below we’ll examine the IReminderDataService interface, which provides some basic data storage functionality.  I’ve implemented two different storage mechanisms: visit SQLite and DB4O posts for specifics.

This interface is basic, a full-fledged interface would provide a bit more. We have Create, Update, Delete and FetchAll functions. You’ll notice that we’re still fully typed at this stage, ensuring that our App isn’t compromised by Casts or creating objects from a result row.

package com.hat6.dataServiceExample.model;

import java.util.List;

public interface IReminderDataService {

	public abstract long createReminder(Reminder r);
	public abstract boolean updateReminder(Reminder r);
	public abstract boolean deleteReminder(Reminder r);
	public abstract List<Reminder> fetchAllReminders();

}

This makes our application very streamlined. We simply instantiate an implementation, fetch all Reminders, then pass the ArrayList over to our ItemRenderers via the RenderedListAdapter (discussed here). It isn’t as generic as a full-on ORM, but it’s very lightweight.

/*... imports removed ...*/
public class DataServiceExample1 extends ListActivity {
	private List<Reminder> reminders;

	/** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        IReminderDataService rds = new ReminderSQLiteImpl(this);
        //createReminders(rds);
        reminders = rds.fetchAllReminders();
        RenderedListAdapter rla = new RenderedListAdapter(this, reminders, ReminderListSimpletemRenderer.class);
        setListAdapter(rla);
    }
    private void createReminders(IReminderDataService rds){
        // Add four items
        Reminder r1 = new Reminder(
                "Remember Once","today", "tomorrow", getResources().getDrawable(R.drawable.finger) );
        Reminder r2 = new Reminder(
                "Bell Reminder","today", "tomorrow", getResources().getDrawable(R.drawable.bell));
        Reminder r3 = new Reminder(
                "Laundry Reminder","today", "tomorrow", getResources().getDrawable(R.drawable.laundry));
        Reminder r4 = new Reminder(
                "Task Reminder","today", "tomorrow", getResources().getDrawable(R.drawable.task));
    	rds.createReminder(r1);
    	rds.createReminder(r2);
    	rds.createReminder(r3);
    	rds.createReminder(r4);
    }
}

You can find the source code for the entire DataService project here: http://svn.hat6.com/hat6public/DataServiceExample/trunk

Coming from the Flex world, it’s strange not to see the idea of “ItemRenderers” in Android.  Customizing the way a List Item looks is much more manual than in Flex, so I’ve come up with a ListAdapter that allows for some of the flexibility/framework-ness that I enjoy in Flex.

I started from this tutorial and modified it to be more Flex-esque.  I’ve tried to keep things as simple and generic as possible.  This is my first draft, so it’s pretty bare-bones, but it does what is needed initially.

To have a List in an Android App, we extend the ListActivity class for a new Activity (I’m only focusing on Activities for now).  From this Activity, we declare and set an Adapter.  The sample code shows using and ArrayAdapter, while this post shows using a SimpleCursorAdapter.  Both of these examples show how to use layouts distributed with Android, but don’t allow much in the way of customization.  They’re poorly documented and searches for “simple_list_item_1″ returns more questions than answers.

So I’ve written my own Adapter that allows you to pass a class to the adapter.  Simply implement IDataRenderer and provide the following constructor: public MyDataRenderer(Context context)

com.hatsix.ListRenderer.RenderedListAdapter.java:

package com.hatsix.ListRenderer;

/*
*
* Copyright 2009 Dusty Jewett
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.List;

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

public class RenderedListAdapter extends BaseAdapter {

/** Remember our context so we can use it when constructing views. */
private Context mContext;
private Class itemRenderer;

private List mItems;

public RenderedListAdapter(Context context, List items, Class renderer) {
mContext = context;
mItems = items;
itemRenderer = renderer;
}

public void setListItems(List list) { mItems = list; }

/** @return The number of items in the */
public int getCount() { return mItems.size(); }

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

public boolean areAllItemsSelectable() { return false; }

public boolean isSelectable(int position) {
/*
try{
return mItems.get(position).isSelectable();
}catch (IndexOutOfBoundsException aioobe){
//return super.isSelectable(position);
return false;
}
*/
return true;
}

/** Use the array index as a unique id. */
public long getItemId(int position) {
return position;
}

/** @param convertView The old view to overwrite, if one is passed
* @returns IDataRenderer View that has had it's data assigned to it */
public View getView(int position, View convertView, ViewGroup parent) {
if (convertView == null) {
try {
View idr;
Class[] rendArgsClass = new Class[] {Context.class};
Object[] rendArgs = new Object[] {mContext};
Constructor rendererConstructor = itemRenderer.getConstructor(rendArgsClass);
idr = (View) createObject(rendererConstructor, rendArgs);
if(idr instanceof IDataRenderer){
((IDataRenderer) idr).setData(mItems.get(position));
}

} catch (NoSuchMethodException e) {
e.printStackTrace();
}//(mContext, mItems.get(position));
}
return convertView;
}
public static Object createObject(Constructor constructor, Object[] arguments) {
Object object = null;
try {
object = constructor.newInstance(arguments);
System.out.println ("Object: " + object.toString());
return object;
} catch (InstantiationException e) {
System.out.println(e);
} catch (IllegalAccessException e) {
System.out.println(e);
} catch (IllegalArgumentException e) {
System.out.println(e);
} catch (InvocationTargetException e) {
System.out.println(e);
}
return object;
}
}

The Interface is super simple, just a setData method:

com.hatsix.ListRenderer.IDataRenderer

package com.hatsix.ListRenderer;

public interface IDataRenderer {
void setData(Object rawData);
Object getData();
}

This class is easy to instantiate in your application:

package com.hatsix;

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

import com.hatsix.ListRenderer.RenderedListAdapter;
import com.hatsix.constantreminder.Reminder;
import com.hatsix.constantreminder.ReminderListItemRenderer;

import android.app.ListActivity;
import android.os.Bundle;

public class RemindersList extends ListActivity {
/** Called when the activity is first created. */
private List<Reminder> reminders;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
reminders = new ArrayList<Reminder>();
// Add four items
reminders.add(new Reminder("Remember Once","today", "tomorrow", getResources().getDrawable(R.drawable.finger) ));
reminders.add(new Reminder("Bell Reminder","today", "tomorrow", getResources().getDrawable(R.drawable.bell)));
reminders.add(new Reminder("Laundry Reminder","today", "tomorrow", getResources().getDrawable(R.drawable.laundry)));
reminders.add(new Reminder("Task Reminder","today", "tomorrow", getResources().getDrawable(R.drawable.task)));

// Display it
RenderedListAdapter rla = new RenderedListAdapter(this, reminders, ReminderListItemRenderer.class);
setListAdapter(rla);
}
}

And the ItemRenderer is really easy. We instantiate our controls, and set the values in setData():
com.hatsix.constantreminder.ReminderListItemRenderer

package com.hatsix.constantreminder;

import com.hatsix.ListRenderer.IDataRenderer;

import android.content.Context;
import android.graphics.drawable.Drawable;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.TextView;

public class ReminderListItemRenderer extends LinearLayout implements IDataRenderer {
private Object data;
private Reminder theReminder;
private TextView mTitle;
private TextView mDescription;
private ImageView mIcon;
private LinearLayout mTextLayout;

public ReminderListItemRenderer(Context context, Object rawData) {
super(context);
this.setOrientation(HORIZONTAL);
/* We're setting up a view that has one icon on the left, and two lines
* of text on the right.
*
* First the Icon
**/
mIcon = new ImageView(context);
mIcon.setPadding(0, 2, 5, 0); // 5px to the right
// left, top, right, bottom (Can't we ever standardize TRBL?)
addView(mIcon,  new LinearLayout.LayoutParams(32,32));

/**
*  Now we do the text lines
*/
mTextLayout = new LinearLayout(context);
mTextLayout.setOrientation(VERTICAL);
addView(mTextLayout);

/* Title */
mTitle = new TextView(context);
mTextLayout.addView(mTitle, new LinearLayout.LayoutParams(
LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT));

/* Description */
mDescription = new TextView(context);
mTextLayout.addView(mDescription, new LinearLayout.LayoutParams(
LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT));
setData(rawData);
}

public void setData(Object rawData){
data = rawData;
if(rawData.getClass() == Reminder.class){
theReminder = (Reminder) data;
mIcon.setImageDrawable(theReminder.getIcon());
mTitle.setText(theReminder.title);
mDescription.setText(theReminder.getDescription());
}
}
}

And finally, the POJO used to pass this data around:

com.hatsix.constantreminder.Reminder

package com.hatsix.constantreminder;

import android.graphics.drawable.Drawable;

public class Reminder {
public String title;
public String start;
public String end;
private Drawable mIcon;
private boolean mSelectable = true;

public Reminder(String t, String s, String e, Drawable icon){
title = t;
start = s;
end = e;
mIcon = icon;
}
public String getDescription(){
return start + " - " + end;
}
public Drawable getIcon(){
return mIcon;
}

}