Merge lp:~ubuntuone-client-engineering/ubuntuone-android-music/metadata-caching-optimisation into lp:ubuntuone-android-music/v2

[Michał Karnicki]

Metadata caching speed optimization.

Metadata caching speed optimization (talking directly to SQLite db in SyncService, instead of talking through content provider abstraction layer). With tests. And some minor test clean-up.

[Roberto Alsina (ralsina)]

review: Approve (code review)

=== modified file 'src/com/ubuntuone/android/music/UbuntuOneMusic.java'
--- src/com/ubuntuone/android/music/UbuntuOneMusic.java	2012-11-13 13:58:31 +0000
+++ src/com/ubuntuone/android/music/UbuntuOneMusic.java	2012-11-21 17:34:22 +0000
@@ -45,11 +45,20 @@
 {
 	public static final String TAG = UbuntuOneMusic.class.getSimpleName();
 	
-	public static final boolean DEBUG_SHOULD_SYNC = true;
-	public static final boolean DEBUG_SHOULD_BIND = true;
-	public static final boolean DEBUG_SHOULD_PLAY = true;
+	/** Should always be true. False would indicate a debug build. */
+	public static final boolean IS_RELEASE = true; // Never commit false.
+	
+	// Following flags have been introduced to ease proper test suite runs and debugging.
+	
+	/** Debug flag indicating if the app should attempt metadata sync. */
+	public static final boolean SHOULD_SYNC = IS_RELEASE;
+	/** Debug flag indicating if the app should bind to {@link MusicService}. */
+	public static final boolean SHOULD_BIND = IS_RELEASE;
+	/** Debug flag indicating if the app should actually playback music. */
+	public static final boolean SHOULD_PLAY = IS_RELEASE;
+	
 	// Set this to true to enable foreign key constraint enforcing.
-	public static final boolean DEBUG_SHOULD_USE_FK = false;
+	public static final boolean SHOULD_USE_FK = true;
 	
 	private static UbuntuOneMusic instance;
 	private U1MusicAPI mApi;
 
=== modified file 'src/com/ubuntuone/android/music/provider/MusicContentValues.java'
--- src/com/ubuntuone/android/music/provider/MusicContentValues.java	2012-11-13 13:58:31 +0000
+++ src/com/ubuntuone/android/music/provider/MusicContentValues.java	2012-11-21 17:34:22 +0000
@@ -25,6 +25,7 @@
 
 import java.util.ArrayList;
 import java.util.Iterator;
+import java.util.Locale;
 import java.util.Map.Entry;
 import java.util.Random;
 import java.util.Set;
@@ -52,12 +53,16 @@
 	
 	private static final boolean PRINT_CONTENT_VALUES = false;
 	
-	public static ContentValues from(U1Artist artist) {
+	public static String getAlbumList(U1Artist artist) {
+		return StringUtils.join(artist.getAlbumIds(), ",");
+	}
+	
+	public static ContentValues forArtist(U1Artist artist) {
 		final ContentValues cv = new ContentValues();
 		cv.put(Artists.UPDATED, System.currentTimeMillis());
 		cv.put(Artists.ARTIST_ID, artist.getId());
 		cv.put(Artists.ARTIST_NAME, artist.getArtist());
-		cv.put(Artists.ALBUM_LIST, StringUtils.join(artist.getAlbumIds(), ","));
+		cv.put(Artists.ALBUM_LIST, getAlbumList(artist));
 		cv.put(Artists.ALBUM_COUNT, artist.getAlbumIds().size());
 		cv.put(Artists.SONG_COUNT, artist.getSongCount());
 		cv.put(Artists.ARTIST_URL, artist.getArtistUrl());
@@ -66,7 +71,7 @@
 		return cv;
 	}
 	
-	public static ArrayList<ContentValues> albumsFrom(U1Artist artist) {
+	public static ArrayList<ContentValues> forArtistAlbums(U1Artist artist) {
 		ArrayList<ContentValues> values = new ArrayList<ContentValues>();
 		ArrayList<String> albumIds = artist.getAlbumIds();
 		for (String albumId : albumIds) {
@@ -80,13 +85,13 @@
 		return values;
 	}
 
-	public static ContentValues from(U1Album album) {
+	public static ContentValues forAlbum(U1Album album) {
 		final ContentValues cv = new ContentValues();
 		cv.put(Albums.UPDATED, System.currentTimeMillis());
 		cv.put(Albums.ALBUM_ID, album.getId());
 		cv.put(Albums.ALBUM_TITLE, album.getTitle());
 		cv.put(Albums.ALBUM_ARTIST, album.getArtist());
-		cv.put(Albums.ALBUM_ARTIST_ID, HashUtils.md5(album.getArtist()));
+		cv.put(Albums.ALBUM_ARTIST_ID, album.getArtistId());
 		cv.put(Albums.ALBUM_YEAR, album.getYear());
 		cv.put(Albums.ALBUM_DATE_ADDED, album.getParsedDate());
 		cv.put(Albums.ALBUM_URL, album.getAlbumUrl());
@@ -95,7 +100,7 @@
 		return cv;
 	}
 	
-	public static ContentValues from(U1Song song) {
+	public static ContentValues forSong(U1Song song) {
 		final ContentValues cv = new ContentValues();
 		cv.put(Songs.UPDATED, System.currentTimeMillis());
 		cv.put(Songs.SONG_ID, song.getId());
@@ -104,10 +109,10 @@
 		cv.put(Songs.SONG_ALBUM_ID, song.getAlbumId());
 		cv.put(Songs.SONG_ALBUM_ARTIST, song.getAlbumArtist());
 		cv.put(Songs.SONG_ARTIST, song.getArtist());
-		cv.put(Songs.SONG_ARTIST_ID,  HashUtils.md5(song.getArtist()));
+		cv.put(Songs.SONG_ARTIST_ID, song.getArtistId());
 		cv.put(Songs.SONG_GENRE, song.getGenre());
 		// TODO Calculate /0 separated genre md5 sums maybe?
-		cv.put(Songs.SONG_GENRE_ID, HashUtils.md5(song.getGenre().toUpperCase()));
+		cv.put(Songs.SONG_GENRE_ID, getGenreId(song.getGenre()));
 		cv.put(Songs.SONG_YEAR, song.getYear());
 		cv.put(Songs.SONG_DISC_NUMBER, song.getDiscNumber());
 		cv.put(Songs.SONG_TRACK, song.getTrack());
@@ -125,7 +130,7 @@
 		return cv;
 	}
 	
-	public static ContentValues from(U1Playlist playlist) {
+	public static ContentValues forPlaylist(U1Playlist playlist) {
 		final ContentValues cv = new ContentValues();
 		cv.put(Playlists.UPDATED, System.currentTimeMillis());
 		cv.put(Playlists.PLAYLIST_ID, playlist.getId());
@@ -136,7 +141,7 @@
 		return cv;
 	}
 	
-	public static ContentValues from(String playlistId, String songId) {
+	public static ContentValues forPlaylistSong(String playlistId, String songId) {
 		final ContentValues cv = new ContentValues();
 		cv.put(PlaylistSongs.UPDATED, System.currentTimeMillis());
 		cv.put(PlaylistSongs.PLAYLIST_ID, playlistId);
@@ -145,7 +150,7 @@
 		return cv;
 	}
 	
-	public static ContentValues from(Random random) {
+	public static ContentValues forShuffleOrder(Random random) {
 		final ContentValues cv = new ContentValues();
 		cv.put(PlaylistSongs.UPDATED, System.currentTimeMillis());
 		cv.put(PlaylistSongs.SHUFFLE_ORDER, random.nextLong());
@@ -153,10 +158,14 @@
 		return cv;
 	}
 	
-	public static ContentValues fromGenre(String genre) {
+	public static String getGenreId(String genre) {
+		return HashUtils.md5(genre.toLowerCase(Locale.US));
+	}
+	
+	public static ContentValues forGenre(String genre) {
 		final ContentValues cv = new ContentValues();
 		cv.put(Genres.UPDATED, System.currentTimeMillis());
-		cv.put(Genres.GENRE_ID, HashUtils.md5(genre.toUpperCase()));
+		cv.put(Genres.GENRE_ID, getGenreId(genre));
 		cv.put(Genres.GENRE_TITLE, genre);
 		return cv;
 	}
 
=== modified file 'src/com/ubuntuone/android/music/provider/MusicContract.java'
--- src/com/ubuntuone/android/music/provider/MusicContract.java	2012-11-08 14:14:54 +0000
+++ src/com/ubuntuone/android/music/provider/MusicContract.java	2012-11-21 17:34:22 +0000
@@ -273,7 +273,7 @@
 		}
 	}
 	
-	/* package */ static class ArtistAlbums implements ArtistAlbumsColumns, SyncColumns,
+	public static class ArtistAlbums implements ArtistAlbumsColumns, SyncColumns,
 			SongsColumns, BaseColumns
 	{
 		public static final Uri CONTENT_URI = BASE_CONTENT_URI.buildUpon()
 
=== modified file 'src/com/ubuntuone/android/music/provider/MusicDatabase.java'
--- src/com/ubuntuone/android/music/provider/MusicDatabase.java	2012-11-13 13:58:31 +0000
+++ src/com/ubuntuone/android/music/provider/MusicDatabase.java	2012-11-21 17:34:22 +0000
@@ -61,7 +61,7 @@
 	
 	//private static final String NOW = "strftime('%s', 'now')";
 
-	interface Tables
+	public interface Tables
 	{
 		String ARTISTS = "artists";
 		String ARTISTS_ALBUMS = "artists_albums";
@@ -115,7 +115,7 @@
 	@Override
 	public SQLiteDatabase getWritableDatabase() {
 		SQLiteDatabase db = super.getWritableDatabase();
-		if (UbuntuOneMusic.DEBUG_SHOULD_USE_FK) {
+		if (UbuntuOneMusic.SHOULD_USE_FK) {
 			db.execSQL("PRAGMA foreign_keys = ON");
 		}
 		return db;
@@ -207,7 +207,7 @@
 		// Create the play queue playlist.
 		U1Playlist queuePlaylist = new U1Playlist(
 				MusicProviderUtils.QUEUE_ID, "", MusicProviderUtils.QUEUE_NAME, 0);
-		ContentValues values = MusicContentValues.from(queuePlaylist);
+		ContentValues values = MusicContentValues.forPlaylist(queuePlaylist);
 		db.insert(Tables.PLAYLISTS, null, values);
 		
 		db.execSQL("CREATE TABLE " + Tables.PLAYLISTS_SONGS + "("
 
=== modified file 'src/com/ubuntuone/android/music/provider/MusicProvider.java'
--- src/com/ubuntuone/android/music/provider/MusicProvider.java	2012-11-08 14:14:54 +0000
+++ src/com/ubuntuone/android/music/provider/MusicProvider.java	2012-11-21 17:34:22 +0000
@@ -325,7 +325,7 @@
 		String lcGenre = genre != null ? genre.trim().toLowerCase() : "";
 		if (!TextUtils.isEmpty(lcGenre) && !lcGenre.equals("null") && !lcGenre.equals("genre")) {
 			// XXX Do we want all genres uppercase? If so, toUpperCase() genre below.
-			ContentValues genreValues = MusicContentValues.fromGenre(genre.trim());
+			ContentValues genreValues = MusicContentValues.forGenre(genre.trim());
 			db.insertOrThrow(Tables.GENRES, null, genreValues);
 		}
 	}
 
=== modified file 'src/com/ubuntuone/android/music/provider/MusicProviderUtils.java'
--- src/com/ubuntuone/android/music/provider/MusicProviderUtils.java	2012-11-08 14:14:54 +0000
+++ src/com/ubuntuone/android/music/provider/MusicProviderUtils.java	2012-11-21 17:34:22 +0000
@@ -242,7 +242,7 @@
 		String playlistId = Playlists.getPlaylistId(playlistUri);
 		String songId = Songs.getSongId(songUri);
 		
-		ContentValues values = MusicContentValues.from(playlistId, songId);
+		ContentValues values = MusicContentValues.forPlaylistSong(playlistId, songId);
 		resolver.insert(playlistUri, values);
 	}
 	
@@ -261,7 +261,7 @@
 			if (cursor != null && cursor.isBeforeFirst()) {
 				while (cursor.moveToNext()) {
 					String songId = cursor.getString(cursor.getColumnIndex(Songs.SONG_ID));
-					ContentValues values = MusicContentValues.from(
+					ContentValues values = MusicContentValues.forPlaylistSong(
 							MusicProviderUtils.QUEUE_ID, songId);
 					resolver.insert(MusicProviderUtils.QUEUE_URI, values);
 				}
@@ -650,7 +650,7 @@
 					String playlistId = cursor.getString(cursor.getColumnIndex(PlaylistSongs.PLAYLIST_ID));
 					String songId = cursor.getString(cursor.getColumnIndex(PlaylistSongs.SONG_ID));
 					Uri queueSongUri = Playlists.buildPlaylistSongUri(playlistId, songId);
-					ContentValues values = MusicContentValues.from(random);
+					ContentValues values = MusicContentValues.forShuffleOrder(random);
 					
 					resolver.update(queueSongUri, values, null, null);
 				}
 
=== added directory 'src/com/ubuntuone/android/music/provider/dao'
=== added file 'src/com/ubuntuone/android/music/provider/dao/AlbumDao.java'
--- src/com/ubuntuone/android/music/provider/dao/AlbumDao.java	1970-01-01 00:00:00 +0000
+++ src/com/ubuntuone/android/music/provider/dao/AlbumDao.java	2012-11-21 17:34:22 +0000
@@ -0,0 +1,130 @@
+package com.ubuntuone.android.music.provider.dao;
+
+import android.content.ContentResolver;
+import android.content.ContentValues;
+import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteStatement;
+import android.net.Uri;
+
+import com.ubuntuone.android.music.provider.MusicContentValues;
+import com.ubuntuone.android.music.provider.MusicContract.Albums;
+import com.ubuntuone.android.music.provider.MusicDatabase;
+import com.ubuntuone.android.music.provider.MusicDatabase.Tables;
+import com.ubuntuone.android.music.provider.MusicProvider;
+import com.ubuntuone.api.music.model.U1Album;
+
+public class AlbumDao extends Dao
+{
+	public AlbumDao() {
+	}
+	
+	/**
+	 * Updates the album. If the album doesn't exist, inserts the album.
+	 * Backed by {@link MusicProvider}.
+	 * 
+	 * @param resolver
+	 *            The content resolver.
+	 * @param artist
+	 *            The {@link U1Album} to save.
+	 */
+	public void updateOrInsert(ContentResolver resolver, U1Album album) {
+		ContentValues values = MusicContentValues.forAlbum(album);
+		Uri albumUri = Albums.buildAlbumUri(album.getId());
+		int count = resolver.update(albumUri, values, null, null);
+		if (count == 0) {
+			resolver.insert(Albums.CONTENT_URI, values);
+		}
+	}
+	
+	/**
+	 * Updates the album. If the album doesn't exist, inserts the album.
+	 * Backed by {@link MusicDatabase}.
+	 * 
+	 * @param db
+	 *            The {@link MusicDatabase} instance.
+	 * @param artist
+	 *            The {@link U1Album} to save.
+	 * @return True if update or insert succeeded, false otherwise.
+	 */
+	public boolean updateOrInsert(SQLiteDatabase db, U1Album album) {
+		boolean isSuccess = false;
+		
+		SQLiteStatement sqlStmt = db.compileStatement(getUpdateSql());
+		int i = 1; // Index to the parameter to bind.
+		sqlStmt.bindLong(i++, System.currentTimeMillis());
+		
+		sqlStmt.bindString(i++, album.getTitle());
+		sqlStmt.bindString(i++, album.getArtist());
+		sqlStmt.bindString(i++, album.getArtistId());
+		sqlStmt.bindLong(i++, album.getYear());
+		
+		sqlStmt.bindLong(i++, album.getParsedDate());
+		sqlStmt.bindString(i++, album.getAlbumUrl());
+		sqlStmt.bindString(i++, album.getAlbumArtUrl());
+		
+		sqlStmt.bindString(i++, album.getId());
+		// Can't use executeUpdateDelete on API < 11
+		sqlStmt.execute();
+		long rowsUpdated = getChanges(db);
+		
+		if (rowsUpdated == 0L) {
+			sqlStmt = db.compileStatement(getInsertSql());
+			i = 1;
+			sqlStmt.bindLong(i++, System.currentTimeMillis());
+			sqlStmt.bindString(i++, album.getId());
+			
+			sqlStmt.bindString(i++, album.getTitle());
+			sqlStmt.bindString(i++, album.getArtist());
+			sqlStmt.bindString(i++, album.getArtistId());
+			sqlStmt.bindLong(i++, album.getYear());
+			
+			sqlStmt.bindLong(i++, album.getParsedDate());
+			sqlStmt.bindString(i++, album.getAlbumUrl());
+			sqlStmt.bindString(i++, album.getAlbumArtUrl());
+			
+			long rowId = sqlStmt.executeInsert();
+			isSuccess = rowId != -1;
+		} else {
+			isSuccess = rowsUpdated == 1;
+		}
+		return isSuccess;
+	}
+
+	@Override
+	public String onGetInsertSql() {
+		return "INSERT INTO " + Tables.ALBUMS + "(" +
+				Albums.UPDATED + ", " +
+				Albums.ALBUM_ID + ", " +
+				
+				Albums.ALBUM_TITLE + ", " +
+				Albums.ALBUM_ARTIST + ", " +
+				Albums.ALBUM_ARTIST_ID + ", " +
+				Albums.ALBUM_YEAR + ", " +
+				
+				Albums.ALBUM_DATE_ADDED + ", " +
+				Albums.ALBUM_URL + ", " +
+				Albums.ALBUM_ART_URL +
+				
+				") VALUES (?, ?, " +
+				"?, ?, ?, ?, " +
+				"?, ?, ?" +
+				")";
+	}
+
+	@Override
+	public String onGetUpdateSql() {
+		return "UPDATE " + Tables.ALBUMS + " SET " +
+				Albums.UPDATED + "=?, " +
+				
+				Albums.ALBUM_TITLE + "=?, " +
+				Albums.ALBUM_ARTIST + "=?, " +
+				Albums.ALBUM_ARTIST_ID + "=?, " +
+				Albums.ALBUM_YEAR + "=?, " +
+				
+				Albums.ALBUM_DATE_ADDED + "=?, " +
+				Albums.ALBUM_URL + "=?, " +
+				Albums.ALBUM_ART_URL + "=? " +
+				
+				"WHERE " + Albums.ALBUM_ID + "=?";
+	}
+}
 
=== added file 'src/com/ubuntuone/android/music/provider/dao/ArtistDao.java'
--- src/com/ubuntuone/android/music/provider/dao/ArtistDao.java	1970-01-01 00:00:00 +0000
+++ src/com/ubuntuone/android/music/provider/dao/ArtistDao.java	2012-11-21 17:34:22 +0000
@@ -0,0 +1,170 @@
+package com.ubuntuone.android.music.provider.dao;
+
+import java.util.ArrayList;
+
+import android.content.ContentResolver;
+import android.content.ContentValues;
+import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteStatement;
+import android.net.Uri;
+
+import com.ubuntuone.android.music.provider.MusicContentValues;
+import com.ubuntuone.android.music.provider.MusicContract.Albums;
+import com.ubuntuone.android.music.provider.MusicContract.ArtistAlbums;
+import com.ubuntuone.android.music.provider.MusicContract.Artists;
+import com.ubuntuone.android.music.provider.MusicDatabase;
+import com.ubuntuone.android.music.provider.MusicDatabase.Tables;
+import com.ubuntuone.android.music.provider.MusicProvider;
+import com.ubuntuone.android.music.util.StringUtils;
+import com.ubuntuone.api.music.model.U1Artist;
+
+public class ArtistDao extends Dao
+{
+	public ArtistDao() {
+	}
+	
+	/**
+	 * Updates the artist. If the artist doesn't exist, inserts the artist.
+	 * Backed by {@link MusicProvider}.
+	 * 
+	 * @param resolver
+	 *            The content resolver.
+	 * @param artist
+	 *            The {@link U1Artist} to save.
+	 */
+	public void updateOrInsert(ContentResolver resolver, U1Artist artist) {
+		ContentValues values = MusicContentValues.forArtist(artist);
+		Uri artistUri = Artists.buildArtistUri(artist.getId());
+		int count = resolver.update(artistUri, values, null, null);
+		if (count == 0) {
+			resolver.insert(Artists.CONTENT_URI, values);
+		}
+		// Insert artist albums.
+		ArrayList<ContentValues> albumsValues = MusicContentValues.forArtistAlbums(artist);
+		for (ContentValues albumValues : albumsValues) {
+			Uri artistAlbumUri = Artists.buildAlbumUri(
+					artist.getId(), albumValues.getAsString(Albums.ALBUM_ID));
+			int count2 = resolver.update(artistAlbumUri, albumValues, null, null);
+			if (count2 == 0) {
+				resolver.insert(artistAlbumUri, albumValues);
+			}
+		}
+	}
+	
+	/**
+	 * Updates the artist. If the artist doesn't exist, inserts the artist.
+	 * Backed by {@link MusicDatabase}.
+	 * 
+	 * @param db
+	 *            The {@link MusicDatabase} instance.
+	 * @param artist
+	 *            The {@link U1Artist} to save.
+	 * @return True if update or insert succeeded, false otherwise.
+	 */
+	public boolean updateOrInsert(SQLiteDatabase db, U1Artist artist) {
+		boolean isSuccess = false;
+		
+		SQLiteStatement sqlStmt = db.compileStatement(getUpdateSql());
+		int i = 1; // Index to the parameter to bind.
+		
+		final String albumList = StringUtils.join(artist.getAlbumIds(), ",");
+		final long albumListSize = artist.getAlbumIds().size();
+		
+		sqlStmt.bindLong(i++, System.currentTimeMillis());
+		
+		sqlStmt.bindString(i++, artist.getArtist());
+		sqlStmt.bindString(i++, albumList);
+		sqlStmt.bindLong(i++, albumListSize);
+		sqlStmt.bindLong(i++, artist.getSongCount());
+		
+		sqlStmt.bindString(i++, artist.getArtistUrl());
+		sqlStmt.bindString(i++, artist.getArtistArtUrl());
+		
+		sqlStmt.bindString(i++, artist.getId());
+		// Can't use executeUpdateDelete on API < 11
+		sqlStmt.execute();
+		long rowsUpdated = getChanges(db);
+		
+		if (rowsUpdated == 0L) {
+			sqlStmt = db.compileStatement(getInsertSql());
+			i = 1;
+			sqlStmt.bindLong(i++, System.currentTimeMillis());
+			sqlStmt.bindString(i++, artist.getId());
+			
+			sqlStmt.bindString(i++, artist.getArtist());
+			sqlStmt.bindString(i++, albumList);
+			sqlStmt.bindLong(i++, albumListSize);
+			sqlStmt.bindLong(i++, artist.getSongCount());
+			
+			sqlStmt.bindString(i++, artist.getArtistUrl());
+			sqlStmt.bindString(i++, artist.getArtistArtUrl());
+			
+			long rowId = sqlStmt.executeInsert();
+			isSuccess = rowId != -1;
+		} else {
+			isSuccess = rowsUpdated == 1;
+		}
+		
+		// Insert artist albums.
+		sqlStmt = db.compileStatement(getSecondaryInsertSql());
+		final String artistId = artist.getId();
+		final ArrayList<String> albumIds = artist.getAlbumIds();
+		for (String albumId : albumIds) {
+			sqlStmt.clearBindings();
+			sqlStmt.bindLong(1, System.currentTimeMillis());
+			sqlStmt.bindString(2, artistId);
+			sqlStmt.bindString(3, albumId);
+			long rowId = sqlStmt.executeInsert();
+			isSuccess = isSuccess && (rowId != -1);
+		}
+		
+		return isSuccess;
+	}
+
+	@Override
+	public String onGetInsertSql() {
+		return "INSERT INTO " + Tables.ARTISTS + "(" +
+				Artists.UPDATED + ", " +
+				Artists.ARTIST_ID + ", " +
+				
+				Artists.ARTIST_NAME + ", " +
+				Artists.ALBUM_LIST + ", " +
+				Artists.ALBUM_COUNT + ", " +
+				Artists.SONG_COUNT + ", " +
+				
+				Artists.ARTIST_URL + ", " +
+				Artists.ARTIST_ART_URL +
+				
+				") VALUES (?, ?, " +
+				"?, ?, ?, ?, " +
+				"?, ?" +
+				")";
+	}
+	
+	@Override
+	public String onGetSecondaryInsertSql() {
+		return "INSERT INTO " + Tables.ARTISTS_ALBUMS + "(" +
+				
+				ArtistAlbums.UPDATED + ", " +
+				ArtistAlbums.ARTIST_ID + ", " +
+				ArtistAlbums.ALBUM_ID +
+				
+				") VALUES (?, ?, ?)";
+	}
+
+	@Override
+	public String onGetUpdateSql() {
+		return "UPDATE " + Tables.ARTISTS + " SET " +
+				Artists.UPDATED + "=?, " +
+				
+				Artists.ARTIST_NAME + "=?, " +
+				Artists.ALBUM_LIST + "=?, " +
+				Artists.ALBUM_COUNT + "=?, " +
+				Artists.SONG_COUNT + "=?, " +
+				
+				Artists.ARTIST_URL + "=?, " +
+				Artists.ARTIST_ART_URL + "=? " +
+				
+				"WHERE " + Artists.ARTIST_ID + "=?";
+	}
+}
 
=== added file 'src/com/ubuntuone/android/music/provider/dao/Dao.java'
--- src/com/ubuntuone/android/music/provider/dao/Dao.java	1970-01-01 00:00:00 +0000
+++ src/com/ubuntuone/android/music/provider/dao/Dao.java	2012-11-21 17:34:22 +0000
@@ -0,0 +1,76 @@
+package com.ubuntuone.android.music.provider.dao;
+
+import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteStatement;
+
+public abstract class Dao
+{
+	private String mInsertSql;
+	private String mSecondaryInsertSql;
+	private String mUdpateSql;
+	
+	/**
+	 * Performs a lazy initialization with {@code Dao#onGetInsertSql()}.
+	 * 
+	 * @return The cached SQL INSERT string.
+	 */
+	public String getInsertSql() {
+		if (mInsertSql == null) {
+			mInsertSql = onGetInsertSql();
+		}
+		return mInsertSql;
+	}
+	
+	/**
+	 * Performs a lazy initialization with {@code Dao#onGetSecondaryInsertSql()}.
+	 * 
+	 * @return The cached secondary SQL INSERT string.
+	 */
+	public String getSecondaryInsertSql() {
+		if (mSecondaryInsertSql == null) {
+			mSecondaryInsertSql = onGetSecondaryInsertSql();
+		}
+		return mSecondaryInsertSql;
+	}
+	
+	/**
+	 * Performs a lazy initialization with {@code Dao#onGetUpdateSql()}.
+	 * 
+	 * @return The cached SQL UPDATE string.
+	 */
+	public String getUpdateSql() {
+		if (mUdpateSql == null) {
+			mUdpateSql = onGetUpdateSql();
+		}
+		return mUdpateSql;
+	}
+	
+	public long getChanges(SQLiteDatabase db) {
+		SQLiteStatement countStmt = db.compileStatement("SELECT changes()");
+		return countStmt.simpleQueryForLong();
+	}
+	
+	/**
+	 * Override to return the SQL INSERT string.
+	 * 
+	 * @return The SQL INSERT string.
+	 */
+	public abstract String onGetInsertSql();
+	
+
+	/**
+	 * Override to return the secondary SQL INSERT string.
+	 * 
+	 * @return The secondary SQL INSERT string.
+	 */
+	public String onGetSecondaryInsertSql() {
+		return null;
+	}
+	
+	/**
+	 * Override to return the SQL UPDATE string.
+	 * 
+	 * @return The SQL UPDATE string.
+	 */
+	public abstract String onGetUpdateSql();
+}
 
=== added file 'src/com/ubuntuone/android/music/provider/dao/GenreDao.java'
--- src/com/ubuntuone/android/music/provider/dao/GenreDao.java	1970-01-01 00:00:00 +0000
+++ src/com/ubuntuone/android/music/provider/dao/GenreDao.java	2012-11-21 17:34:22 +0000
@@ -0,0 +1,86 @@
+package com.ubuntuone.android.music.provider.dao;
+
+import android.content.ContentResolver;
+import android.content.ContentValues;
+import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteStatement;
+import android.text.TextUtils;
+
+import com.ubuntuone.android.music.provider.MusicContentValues;
+import com.ubuntuone.android.music.provider.MusicContract.Genres;
+import com.ubuntuone.android.music.provider.MusicDatabase;
+import com.ubuntuone.android.music.provider.MusicDatabase.Tables;
+import com.ubuntuone.android.music.provider.MusicProvider;
+import com.ubuntuone.android.music.util.HashUtils;
+import com.ubuntuone.api.music.model.U1Song;
+
+public class GenreDao extends Dao
+{
+	public GenreDao() {
+	}
+	
+	/**
+	 * Inserts song genre. Backed by {@link MusicProvider}.
+	 * 
+	 * @param resolver
+	 *            The content resolver.
+	 * @param song
+	 *            The {@link U1Song} of which genre to save.
+	 */
+	public void updateOrInsert(ContentResolver resolver, U1Song song) {
+		String genre = song.getGenre();
+		String lcGenre = genre != null ? genre.trim().toLowerCase() : null;
+		if (!TextUtils.isEmpty(lcGenre) &&
+				!lcGenre.equals("null") && !lcGenre.equals("genre")) {
+			// XXX Do we want all genres uppercase? If so, toUpperCase() genre below.
+			ContentValues genreValues = MusicContentValues.forGenre(genre.trim());
+			resolver.insert(Genres.CONTENT_URI, genreValues);
+		}
+	}
+	
+	/**
+	 * Inserts song genre. Backed by {@link MusicDatabase}.
+	 * 
+	 * @param db
+	 *            The {@link MusicDatabase} instance.
+	 * @param song
+	 *            The {@link U1Song} of which genre to save.
+	 * @return Always true for genre.
+	 */
+	public boolean updateOrInsert(SQLiteDatabase db, String genre) {
+		final SQLiteStatement genreInsert = db.compileStatement(getInsertSql());
+		genreInsert.clearBindings();
+		
+		String lcGenre = genre != null ? genre.trim().toLowerCase() : null;
+		if (TextUtils.isEmpty(lcGenre) ||
+				lcGenre.equals("null") || lcGenre.equals("genre")) {
+			// Ignore generic crap. Assume genre was inserted, we don't care.
+			return true;
+		}
+		String genreId = HashUtils.md5(genre.toUpperCase());
+		
+		int j = 1; // Index to the parameter to bind.
+		genreInsert.bindLong(j++, System.currentTimeMillis());
+		genreInsert.bindString(j++, genreId);
+		genreInsert.bindString(j++, genre);
+		
+		genreInsert.executeInsert();
+		// Assume genre was inserted, we don't care.
+		return true;
+	}
+
+	@Override
+	public String onGetInsertSql() {
+		return "INSERT INTO " + Tables.GENRES + "(" +
+				Genres.UPDATED + ", " +
+				Genres.GENRE_ID + ", " +
+				Genres.GENRE_TITLE + 
+				") VALUES (?, ?, ?)";
+	}
+
+	@Override
+	public String onGetUpdateSql() {
+		// Not used for genre.
+		return null;
+	}
+}
 
=== added file 'src/com/ubuntuone/android/music/provider/dao/PlaylistDao.java'
--- src/com/ubuntuone/android/music/provider/dao/PlaylistDao.java	1970-01-01 00:00:00 +0000
+++ src/com/ubuntuone/android/music/provider/dao/PlaylistDao.java	2012-11-21 17:34:22 +0000
@@ -0,0 +1,109 @@
+package com.ubuntuone.android.music.provider.dao;
+
+import android.content.ContentResolver;
+import android.content.ContentValues;
+import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteStatement;
+import android.net.Uri;
+
+import com.ubuntuone.android.music.provider.MusicContentValues;
+import com.ubuntuone.android.music.provider.MusicContract.Playlists;
+import com.ubuntuone.android.music.provider.MusicDatabase;
+import com.ubuntuone.android.music.provider.MusicDatabase.Tables;
+import com.ubuntuone.android.music.provider.MusicProvider;
+import com.ubuntuone.api.music.model.U1Playlist;
+
+public class PlaylistDao extends Dao
+{
+	public PlaylistDao() {
+	}
+	
+	/**
+	 * Updates the playlist. If the playlist doesn't exist, inserts the playlist.
+	 * Backed by {@link MusicProvider}.
+	 * 
+	 * @param resolver
+	 *            The content resolver.
+	 * @param playlist
+	 *            The {@link U1Playlist} to save.
+	 */
+	public void updateOrInsert(ContentResolver resolver, U1Playlist playlist) {
+		ContentValues values = MusicContentValues.forPlaylist(playlist);
+		Uri playlistUri = Playlists.buildPlaylistUri(playlist.getId());
+		int count = resolver.update(playlistUri, values, null, null);
+		if (count == 0) {
+			resolver.insert(Playlists.CONTENT_URI, values);
+		}
+	}
+	
+	/**
+	 * Updates the playlist. If the playlist doesn't exist, inserts the playlist.
+	 * Backed by {@link MusicDatabase}.
+	 * 
+	 * @param db
+	 *            The {@link MusicDatabase} instance.
+	 * @param playlist
+	 *            The {@link U1Playlist} to save.
+	 * @return True if update or insert succeeded, false otherwise.
+	 */
+	public boolean updateOrInsert(SQLiteDatabase db, U1Playlist playlist) {
+		boolean isSuccess = false;
+		
+		SQLiteStatement sqlStmt = db.compileStatement(getUpdateSql());
+		int i = 1; // Index to the parameter to bind.
+		
+		sqlStmt.bindLong(i++, System.currentTimeMillis());
+		
+		sqlStmt.bindString(i++, playlist.getName());
+		sqlStmt.bindLong(i++, playlist.getSongCount());
+		sqlStmt.bindString(i++, playlist.getPlaylistUrl());
+		
+		sqlStmt.bindString(i++, playlist.getId());
+		// Can't use executeUpdateDelete on API < 11
+		sqlStmt.execute();
+		long rowsUpdated = getChanges(db);
+		
+		if (rowsUpdated == 0L) {
+			sqlStmt = db.compileStatement(getInsertSql());
+			i = 1;
+			sqlStmt.bindLong(i++, System.currentTimeMillis());
+		
+			sqlStmt.bindString(i++, playlist.getId());
+			sqlStmt.bindString(i++, playlist.getName());
+			sqlStmt.bindLong(i++, playlist.getSongCount());
+			sqlStmt.bindString(i++, playlist.getPlaylistUrl());
+			
+			long rowId = sqlStmt.executeInsert();
+			isSuccess = rowId != -1;
+		} else {
+			isSuccess = rowsUpdated == 1;
+		}
+		return isSuccess;
+	}
+
+	@Override
+	public String onGetInsertSql() {
+		return "INSERT INTO " + Tables.PLAYLISTS + "(" +
+				Playlists.UPDATED + ", " +
+				Playlists.PLAYLIST_ID + ", " +
+				
+				Playlists.PLAYLIST_NAME + ", " +
+				Playlists.PLAYLIST_SONG_COUNT + ", " +
+				Playlists.PLAYLIST_URL +
+				
+				") VALUES (?, ?, " +
+				"?, ?, ?" +
+				")";
+	}
+
+	@Override
+	public String onGetUpdateSql() {
+		return "UPDATE " + Tables.PLAYLISTS + " SET " +
+				Playlists.UPDATED + "=?, " +
+				Playlists.PLAYLIST_NAME + "=?, " +
+				Playlists.PLAYLIST_SONG_COUNT + "=?, " +
+				Playlists.PLAYLIST_URL + "=? " +
+				"WHERE " + Playlists.PLAYLIST_ID + "=?";
+		
+	}
+}
 
=== added file 'src/com/ubuntuone/android/music/provider/dao/PlaylistSongDao.java'
--- src/com/ubuntuone/android/music/provider/dao/PlaylistSongDao.java	1970-01-01 00:00:00 +0000
+++ src/com/ubuntuone/android/music/provider/dao/PlaylistSongDao.java	2012-11-21 17:34:22 +0000
@@ -0,0 +1,97 @@
+package com.ubuntuone.android.music.provider.dao;
+
+import android.content.ContentResolver;
+import android.content.ContentValues;
+import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteStatement;
+import android.net.Uri;
+
+import com.ubuntuone.android.music.provider.MusicContentValues;
+import com.ubuntuone.android.music.provider.MusicContract.PlaylistSongs;
+import com.ubuntuone.android.music.provider.MusicContract.Playlists;
+import com.ubuntuone.android.music.provider.MusicContract.Songs;
+import com.ubuntuone.android.music.provider.MusicDatabase;
+import com.ubuntuone.android.music.provider.MusicDatabase.Tables;
+import com.ubuntuone.android.music.provider.MusicProvider;
+import com.ubuntuone.api.music.model.U1Song;
+
+public class PlaylistSongDao extends Dao
+{
+	public PlaylistSongDao() {
+	}
+	
+	/**
+	 * Updates the playlist song. If the playlist song doesn't exist, inserts
+	 * the playlist song. Backed by {@link MusicProvider}.
+	 * 
+	 * @param resolver
+	 *            The content resolver.
+	 * @param playlistId
+	 *            The playlist id of the playlist to save the song to.
+	 * @param song
+	 *            The {@link U1Song} to save.
+	 */
+	public void updateOrInsert(ContentResolver resolver, String playlistId, U1Song song) {
+		ContentValues values = MusicContentValues.forPlaylistSong(playlistId, song.getId());
+		Uri playlistSongsUri = Playlists.buildPlaylistSongUri(playlistId, song.getId());
+		int count = resolver.update(playlistSongsUri, values, null, null);
+		if (count == 0) {
+			resolver.insert(playlistSongsUri, values);
+		}
+	}
+	
+	/**
+	 * Updates the playlist song. If the playlist song doesn't exist, inserts
+	 * the playlist song. Backed by {@link MusicDatabase}.
+	 * 
+	 * @param db
+	 *            The {@link MusicDatabase} instance.
+	 * @param playlistId
+	 *            The playlist id of the playlist to save the song to.
+	 * @param song
+	 *            The {@link U1Song} to save.
+	 * @return True if update or insert succeeded, false otherwise.
+	 */
+	public boolean updateOrInsert(SQLiteDatabase db, String playlistId, String songId) {
+		boolean isSuccess = false;
+		
+		SQLiteStatement sqlStmt = db.compileStatement(getUpdateSql());
+		int i = 1; // Index to the parameter to bind.
+		sqlStmt.bindLong(i++, System.currentTimeMillis());
+		sqlStmt.bindString(i++, playlistId);
+		sqlStmt.bindString(i++, songId);
+		// Can't use executeUpdateDelete on API < 11
+		sqlStmt.execute();
+		long rowsUpdated = getChanges(db);
+		
+		if (rowsUpdated == 0L) {
+			sqlStmt = db.compileStatement(getInsertSql());
+			i = 1;
+			sqlStmt.bindLong(i++, System.currentTimeMillis());
+			sqlStmt.bindString(i++, playlistId);
+			sqlStmt.bindString(i++, songId);
+			
+			long rowId = sqlStmt.executeInsert();
+			isSuccess = rowId != -1;
+		} else {
+			isSuccess = rowsUpdated == 1;
+		}
+		return isSuccess;
+	}
+
+	@Override
+	public String onGetInsertSql() {
+		return "INSERT INTO " + Tables.PLAYLISTS_SONGS + "(" +
+				PlaylistSongs.UPDATED + ", " +
+				PlaylistSongs.PLAYLIST_ID + ", " +
+				PlaylistSongs.SONG_ID +
+				") VALUES (?, ?, ?)";
+	}
+
+	@Override
+	public String onGetUpdateSql() {
+		return "UPDATE " + Tables.PLAYLISTS_SONGS + " SET " +
+				PlaylistSongs.UPDATED + "=? " +
+				"WHERE " + PlaylistSongs.PLAYLIST_ID + "=? AND " + Songs.SONG_ID + "=?";
+	}
+}
 
=== added file 'src/com/ubuntuone/android/music/provider/dao/SongDao.java'
--- src/com/ubuntuone/android/music/provider/dao/SongDao.java	1970-01-01 00:00:00 +0000
+++ src/com/ubuntuone/android/music/provider/dao/SongDao.java	2012-11-21 17:34:22 +0000
@@ -0,0 +1,194 @@
+package com.ubuntuone.android.music.provider.dao;
+
+import static com.ubuntuone.android.music.provider.MusicContentValues.getGenreId;
+import android.content.ContentResolver;
+import android.content.ContentValues;
+import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteStatement;
+import android.net.Uri;
+
+import com.ubuntuone.android.music.provider.MusicContentValues;
+import com.ubuntuone.android.music.provider.MusicContract.Songs;
+import com.ubuntuone.android.music.provider.MusicDatabase;
+import com.ubuntuone.android.music.provider.MusicDatabase.Tables;
+import com.ubuntuone.android.music.provider.MusicProvider;
+import com.ubuntuone.api.music.model.U1Song;
+
+public class SongDao extends Dao
+{
+	public SongDao() {
+	}
+	
+	/**
+	 * Updates the song. If the song doesn't exist, inserts the song. Backed by
+	 * {@link MusicProvider}.
+	 * 
+	 * @param resolver
+	 *            The content resolver.
+	 * @param song
+	 *            The {@link U1Song} to save.
+	 */
+	public void updateOrInsert(ContentResolver resolver, U1Song song) {
+		ContentValues values = MusicContentValues.forSong(song);
+		Uri songUri = Songs.buildSongUri(song.getId());
+		int rowsUpdated = resolver.update(songUri, values, null, null);
+		if (rowsUpdated == 0) {
+			resolver.insert(Songs.CONTENT_URI, values);
+		}
+	}
+	
+	/**
+	 * Updates the song. If the song doesn't exist, inserts the song. Backed by
+	 * {@link MusicDatabase}.
+	 * 
+	 * @param db
+	 *            The {@link MusicDatabase} instance.
+	 * @param song
+	 *            The {@link U1Song} to save.
+	 * @return True if update or insert succeeded, false otherwise.
+	 */
+	public boolean updateOrInsert(SQLiteDatabase db, U1Song song) {
+		boolean isSuccess = false;
+		
+		SQLiteStatement sqlStmt = db.compileStatement(getUpdateSql());
+		int i = 1; // Index to the parameter to bind.
+		sqlStmt.bindLong(i++, System.currentTimeMillis());
+		
+		sqlStmt.bindString(i++, song.getTitle());
+		sqlStmt.bindString(i++, song.getAlbum());
+		sqlStmt.bindString(i++, song.getAlbumId());
+		sqlStmt.bindString(i++, song.getAlbumArtist());
+		
+		sqlStmt.bindString(i++, song.getArtist());
+		sqlStmt.bindString(i++, song.getArtistId());
+		sqlStmt.bindString(i++, song.getGenre());
+		sqlStmt.bindString(i++, getGenreId(song.getGenre()));
+		
+		sqlStmt.bindLong(i++, song.getYear());
+		sqlStmt.bindLong(i++, song.getDiscNumber());
+		sqlStmt.bindLong(i++, song.getTrack());
+		sqlStmt.bindLong(i++, song.getDuration());
+		
+		sqlStmt.bindLong(i++, song.getSize());
+		sqlStmt.bindLong(i++, song.getBitRate());
+		sqlStmt.bindString(i++, song.getSuffix());
+		sqlStmt.bindString(i++, song.getContentType());
+		
+		sqlStmt.bindString(i++, song.getSongUrl());
+		sqlStmt.bindString(i++, song.getSongArtUrl());
+		sqlStmt.bindString(i++, song.getSongStreamUrl());
+		
+		sqlStmt.bindString(i++, song.getId());
+		// Can't use executeUpdateDelete on API < 11
+		sqlStmt.execute();
+		long rowsUpdated = getChanges(db);
+		
+		if (rowsUpdated == 0L) {
+			sqlStmt = db.compileStatement(getInsertSql());
+			i = 1;
+			sqlStmt.bindLong(i++, System.currentTimeMillis());
+			sqlStmt.bindString(i++, song.getId());
+			
+			sqlStmt.bindString(i++, song.getTitle());
+			sqlStmt.bindString(i++, song.getAlbum());
+			sqlStmt.bindString(i++, song.getAlbumId());
+			sqlStmt.bindString(i++, song.getAlbumArtist());
+			
+			sqlStmt.bindString(i++, song.getArtist());
+			sqlStmt.bindString(i++, song.getArtistId());
+			sqlStmt.bindString(i++, song.getGenre());
+			sqlStmt.bindString(i++, getGenreId(song.getGenre()));
+			
+			sqlStmt.bindLong(i++, song.getYear());
+			sqlStmt.bindLong(i++, song.getDiscNumber());
+			sqlStmt.bindLong(i++, song.getTrack());
+			sqlStmt.bindLong(i++, song.getDuration());
+			
+			sqlStmt.bindLong(i++, song.getSize());
+			sqlStmt.bindLong(i++, song.getBitRate());
+			sqlStmt.bindString(i++, song.getSuffix());
+			sqlStmt.bindString(i++, song.getContentType());
+			
+			sqlStmt.bindString(i++, song.getSongUrl());
+			sqlStmt.bindString(i++, song.getSongArtUrl());
+			sqlStmt.bindString(i++, song.getSongStreamUrl());
+			
+			long rowId = sqlStmt.executeInsert();
+			isSuccess = rowId != -1;
+		} else {
+			isSuccess = rowsUpdated == 1;
+		}
+		return isSuccess;
+	}
+
+	@Override
+	public String onGetInsertSql() {
+		return "INSERT INTO " + Tables.SONGS + "(" +
+				Songs.UPDATED + ", " +
+				Songs.SONG_ID + ", " +
+				
+				Songs.SONG_TITLE + ", " +
+				Songs.SONG_ALBUM + ", " +
+				Songs.SONG_ALBUM_ID + ", " +
+				Songs.SONG_ALBUM_ARTIST + ", " +
+				
+				Songs.SONG_ARTIST + ", " +
+				Songs.SONG_ARTIST_ID + ", " +
+				Songs.SONG_GENRE + ", " +
+				Songs.SONG_GENRE_ID + ", " +
+				
+				Songs.SONG_YEAR + ", " +
+				Songs.SONG_DISC_NUMBER + ", " +
+				Songs.SONG_TRACK + ", " +
+				Songs.SONG_DURATION + ", " +
+				
+				Songs.SONG_SIZE + ", " +
+				Songs.SONG_BIT_RATE + ", " +
+				Songs.SONG_SUFFIX + ", " +
+				Songs.SONG_CONTENT_TYPE + ", " +
+				
+				Songs.SONG_URL + ", " +
+				Songs.SONG_ART_URL + ", " +
+				Songs.SONG_STREAM_URL +
+				
+				") VALUES (?, ?, " +
+				"?, ?, ?, ?, " +
+				"?, ?, ?, ?, " +
+				"?, ?, ?, ?, " +
+				"?, ?, ?, ?, " +
+				"?, ?, ?" +
+				")";
+	}
+
+	@Override
+	public String onGetUpdateSql() {
+		return "UPDATE " + Tables.SONGS + " SET " +
+				Songs.UPDATED + "=?, " +
+				
+				Songs.SONG_TITLE + "=?, " +
+				Songs.SONG_ALBUM + "=?, " +
+				Songs.SONG_ALBUM_ID + "=?, " +
+				Songs.SONG_ALBUM_ARTIST + "=?, " +
+				
+				Songs.SONG_ARTIST + "=?, " +
+				Songs.SONG_ARTIST_ID + "=?, " +
+				Songs.SONG_GENRE + "=?, " +
+				Songs.SONG_GENRE_ID + "=?, " +
+				
+				Songs.SONG_YEAR + "=?, " +
+				Songs.SONG_DISC_NUMBER + "=?, " +
+				Songs.SONG_TRACK + "=?, " +
+				Songs.SONG_DURATION + "=?, " +
+				
+				Songs.SONG_SIZE + "=?, " +
+				Songs.SONG_BIT_RATE + "=?, " +
+				Songs.SONG_SUFFIX + "=?, " +
+				Songs.SONG_CONTENT_TYPE + "=?, " +
+				
+				Songs.SONG_URL + "=?, " +
+				Songs.SONG_ART_URL + "=?, " +
+				Songs.SONG_STREAM_URL + "=? " +
+				
+				"WHERE " + Songs.SONG_ID + "=?";
+	}
+}
 
=== modified file 'src/com/ubuntuone/android/music/service/MusicService.java'
--- src/com/ubuntuone/android/music/service/MusicService.java	2012-11-08 23:02:13 +0000
+++ src/com/ubuntuone/android/music/service/MusicService.java	2012-11-21 17:34:22 +0000
@@ -384,7 +384,7 @@
 	
 	public synchronized void resume() {
 		try {
-			if (UbuntuOneMusic.DEBUG_SHOULD_PLAY) {
+			if (UbuntuOneMusic.SHOULD_PLAY) {
 				mMediaPlayer.start();
 			}
 			setPlayerState(STARTED);
@@ -594,7 +594,7 @@
 				mMediaPlayer.seekTo(position);
 			}
 			
-			if (UbuntuOneMusic.DEBUG_SHOULD_PLAY) {
+			if (UbuntuOneMusic.SHOULD_PLAY) {
 				mMediaPlayer.start();
 			}
 			setPlayerState(STARTED);
 
=== modified file 'src/com/ubuntuone/android/music/service/SyncService.java'
--- src/com/ubuntuone/android/music/service/SyncService.java	2012-11-08 14:14:54 +0000
+++ src/com/ubuntuone/android/music/service/SyncService.java	2012-11-21 17:34:22 +0000
@@ -21,32 +21,32 @@
 
 package com.ubuntuone.android.music.service;
 
-import static com.ubuntuone.android.music.util.LogUtils.LOGD;
-import static com.ubuntuone.android.music.util.LogUtils.LOGE;
 import static com.ubuntuone.android.music.util.LogUtils.makeLogTag;
-
-import java.util.ArrayList;
-
 import android.app.IntentService;
 import android.content.ContentResolver;
-import android.content.ContentValues;
 import android.content.Context;
 import android.content.Intent;
 import android.database.Cursor;
-import android.net.Uri;
+import android.database.sqlite.SQLiteDatabase;
 import android.os.Bundle;
 import android.os.ResultReceiver;
 import android.util.Log;
 
 import com.ubuntuone.android.music.R;
 import com.ubuntuone.android.music.UbuntuOneMusic;
-import com.ubuntuone.android.music.provider.MusicContentValues;
 import com.ubuntuone.android.music.provider.MusicContract.Albums;
 import com.ubuntuone.android.music.provider.MusicContract.Artists;
 import com.ubuntuone.android.music.provider.MusicContract.Playlists;
 import com.ubuntuone.android.music.provider.MusicContract.Songs;
 import com.ubuntuone.android.music.provider.MusicContract.SyncColumns;
+import com.ubuntuone.android.music.provider.MusicDatabase;
 import com.ubuntuone.android.music.provider.MusicProviderUtils;
+import com.ubuntuone.android.music.provider.dao.AlbumDao;
+import com.ubuntuone.android.music.provider.dao.ArtistDao;
+import com.ubuntuone.android.music.provider.dao.GenreDao;
+import com.ubuntuone.android.music.provider.dao.PlaylistDao;
+import com.ubuntuone.android.music.provider.dao.PlaylistSongDao;
+import com.ubuntuone.android.music.provider.dao.SongDao;
 import com.ubuntuone.android.music.util.AccountUtils;
 import com.ubuntuone.android.music.util.UIUtils;
 import com.ubuntuone.api.music.U1MusicAPI;
@@ -73,7 +73,8 @@
 	public static final int SYNC_STARTED = 1;
 	public static final int SYNC_PROGRESS = 2;
 	public static final int SYNC_FINISHED = 3;
-
+	
+	private static final boolean DIRECT_SQL = true;
 	
 	private static int sSyncStatus = 0;
 	
@@ -104,7 +105,7 @@
 		mReceiver = intent.getParcelableExtra(EXTRA_RECEIVER);
 		if (action != null && ACTION_SYNC_MUSIC_METADATA.equals(action)) {
 			mTimeSyncStarted = System.currentTimeMillis();
-			if (mApi != null && UbuntuOneMusic.DEBUG_SHOULD_SYNC) {
+			if (mApi != null && UbuntuOneMusic.SHOULD_SYNC) {
 				sSyncStatus = SYNC_STARTED;
 				if (mReceiver != null) mReceiver.send(SYNC_STARTED, Bundle.EMPTY);
 				syncMusicMetadata();
@@ -122,37 +123,49 @@
 		syncSongs();
 		syncPlaylists();
 		syncPlaylistSongs();
-		// Don't purge if network has gone away.
+		// Purge only if network connection still present.
 		if (UIUtils.isNetworkConnected(this)) {
 			purgeInvalidData(mTimeSyncStarted);
 		}
 	}
 	
 	private void syncArtists() {
+		final long timeMillis = System.currentTimeMillis();
 		mApi.getArtists(mArtistListener);
+		final long nowMillis = System.currentTimeMillis();
+		Log.i(TAG, "Artists sync took " + (nowMillis - timeMillis) + "ms");
 	}
 	
 	private void syncAlbums() {
+		final long timeMillis = System.currentTimeMillis();
 		mApi.getAlbums(mAlbumListener);
+		final long nowMillis = System.currentTimeMillis();
+		Log.i(TAG, "Albums sync took " + (nowMillis - timeMillis) + "ms");
 	}
 	
 	private void syncSongs() {
+		final long timeMillis = System.currentTimeMillis();
 		mApi.getSongs(mSongListener);
+		final long nowMillis = System.currentTimeMillis();
+		Log.i(TAG, "Songs sync took " + (nowMillis - timeMillis) + "ms");
 	}
 	
 	private void syncPlaylists() {
+		final long timeMillis = System.currentTimeMillis();
 		mApi.getPlaylists(mPlaylistListener);
+		final long nowMillis = System.currentTimeMillis();
+		Log.i(TAG, "Playlists sync took " + (nowMillis - timeMillis) + "ms");
 	}
 	
 	private void syncPlaylistSongs() {
+		final long timeMillis = System.currentTimeMillis();
 		Cursor cursor = null;
 		try {
 			String[] projection = new String[] { Playlists.PLAYLIST_ID };
 			cursor = getContentResolver().query(Playlists.CONTENT_URI, projection,
 					null, null, null);
 			while (cursor.moveToNext()) {
-				String playlistId = cursor.getString(
-						cursor.getColumnIndexOrThrow(Playlists.PLAYLIST_ID));
+				String playlistId = cursor.getString(cursor.getColumnIndex(Playlists.PLAYLIST_ID));
 				if (MusicProviderUtils.QUEUE_ID.equals(playlistId)) continue;
 				mPlaylistSongListener.setPlaylist(playlistId);
 				mApi.getPlaylist(playlistId, mPlaylistSongListener);
@@ -160,163 +173,197 @@
 		} finally {
 			if (cursor != null) cursor.close();
 		}
+		final long nowMillis = System.currentTimeMillis();
+		Log.i(TAG, "Playlist songs sync took " + (nowMillis - timeMillis) + "ms");
 	}
 	
 	private U1ArtistListener mArtistListener = new U1ArtistListener() {
+		private SQLiteDatabase db;
+		private ArtistDao artistDao = new ArtistDao();
+		private Bundle progressBundle = new Bundle();
+		private Failure failure = null;
 		private int artistCount = 0;
-		private int artistAlbumCount = 0;
-		
-		private Bundle progressBundle = new Bundle();
 		
 		@Override
 		public void onStart() {
-			LOGD(TAG, "Syncing artists...");
+			Log.d(TAG, "Syncing artists...");
+			if (DIRECT_SQL) {
+				db = new MusicDatabase(SyncService.this).getWritableDatabase();
+				db.beginTransaction();
+			}
 			progressBundle.putInt(EXTRA_LOADER_ID, R.id.artist_loader_id);
 		}
 
 		@Override
 		public void onSuccess(U1Artist artist) {
 			artistCount++;
-			ContentValues values = MusicContentValues.from(artist);
-			Uri artistUri = Artists.buildArtistUri(artist.getId());
-			int count = mResolver.update(artistUri, values, null, null);
-			if (count == 0) {
-				mResolver.insert(Artists.CONTENT_URI, values);
-			}
-			// Insert artist albums.
-			ArrayList<ContentValues> albumsValues = MusicContentValues.albumsFrom(artist);
-			for (ContentValues albumValues : albumsValues) {
-				Uri artistAlbumUri = Artists.buildAlbumUri(
-						artist.getId(), albumValues.getAsString(Albums.ALBUM_ID));
-				artistAlbumCount++;
-				int count2 = mResolver.update(artistAlbumUri, albumValues, null, null);
-				if (count2 == 0) {
-					mResolver.insert(artistAlbumUri, albumValues);
-				}
+			if (DIRECT_SQL) {
+				artistDao.updateOrInsert(db, artist);
+			} else {
+				artistDao.updateOrInsert(mResolver, artist);
 			}
 			mReceiver.send(SYNC_PROGRESS, progressBundle);
 		}
 
 		@Override
 		public void onFailure(Failure failure) {
-			LOGE(TAG, String.format("Failed to get artists: %d -- %s",
+			this.failure = failure;
+			Log.e(TAG, String.format("Failed to get artists: %d -- %s",
 					failure.getStatusCode(), failure.getMessage()));
 		}
 
 		@Override
 		public void onFinish() {
-			LOGD(TAG, String.format("Finished syncing artists " +
-					"(got %d artists, %d artist albums).", artistCount, artistAlbumCount));
+			if (DIRECT_SQL) {
+				if (failure == null) db.setTransactionSuccessful();
+				db.endTransaction();
+				db.close();
+			}
+			Log.d(TAG, String.format("Finished syncing artists " +
+					"(got %d artists).", artistCount));
 		}
 	};
 	
 	private U1AlbumListener mAlbumListener = new U1AlbumListener() {
+		private SQLiteDatabase db;
+		private AlbumDao albumDao = new AlbumDao();
+		private Bundle progressBundle = new Bundle();
+		private Failure failure = null;
 		private int albumCount = 0;
 		
-		private Bundle progressBundle = new Bundle();
-		
 		@Override
 		public void onStart() {
-			LOGD(TAG, "Syncing albums...");
+			Log.d(TAG, "Syncing albums...");
+			if (DIRECT_SQL) {
+				db = new MusicDatabase(SyncService.this).getWritableDatabase();
+				db.beginTransaction();
+			}
 			progressBundle.putInt(EXTRA_LOADER_ID, R.id.album_loader_id);
 		}
 		
 		@Override
 		public void onSuccess(U1Album album) {
 			albumCount++;
-			ContentValues values = MusicContentValues.from(album);
-			Uri albumUri = Albums.buildAlbumUri(album.getId());
-			int count = mResolver.update(albumUri, values, null, null);
-			if (count == 0) {
-				mResolver.insert(Albums.CONTENT_URI, values);
+			if (DIRECT_SQL) {
+				albumDao.updateOrInsert(db, album);
+			} else {
+				albumDao.updateOrInsert(mResolver, album);
 			}
 			mReceiver.send(SYNC_PROGRESS, progressBundle);
 		}
 
 		@Override
 		public void onFailure(Failure failure) {
-			super.onFailure(failure);
-			LOGE(TAG, String.format("Failed to get albums: %d -- %s",
+			this.failure = failure;
+			Log.e(TAG, String.format("Failed to get albums: %d -- %s",
 					failure.getStatusCode(), failure.getMessage()));
 		}
 		
 		@Override
 		public void onFinish() {
-			LOGD(TAG, String.format("Finished syncing albums (got %s albums).",
+			if (DIRECT_SQL) {
+				if (failure == null) db.setTransactionSuccessful();
+				db.endTransaction();
+				db.close();
+			}
+			Log.d(TAG, String.format("Finished syncing albums (got %s albums).",
 					albumCount));
 		}
 	};
 	
 	private U1SongListener mSongListener = new U1SongListener() {
+		private SQLiteDatabase db;
+		private SongDao songDao = new SongDao();
+		private GenreDao genreDao = new GenreDao();
+		private Bundle progressBundle = new Bundle();
+		private Failure failure = null;
 		private int songCount = 0;
 		
-		private Bundle progressBundle = new Bundle();
-		
 		@Override
 		public void onStart() {
-			LOGD(TAG, "Syncing songs...");
+			Log.d(TAG, "Syncing songs...");
+			if (DIRECT_SQL) {
+				db = new MusicDatabase(SyncService.this).getWritableDatabase();
+				db.beginTransaction();
+			}
 			progressBundle.putInt(EXTRA_LOADER_ID, R.id.song_loader_id);
 		}
 		
 		@Override
 		public void onSuccess(U1Song song) {
 			songCount++;
-			ContentValues values = MusicContentValues.from(song);
-			Uri songUri = Songs.buildSongUri(song.getId());
-			int count = mResolver.update(songUri, values, null, null);
-			if (count == 0) {
-				mResolver.insert(Songs.CONTENT_URI, values);
+			if (DIRECT_SQL) {
+				if (songDao.updateOrInsert(db, song)) {
+					genreDao.updateOrInsert(db, song.getGenre());
+				}
+			} else {
+				songDao.updateOrInsert(mResolver, song);
 			}
 			mReceiver.send(SYNC_PROGRESS, progressBundle);
 		}
 
 		@Override
 		public void onFailure(Failure failure) {
-			super.onFailure(failure);
-			LOGE(TAG, String.format("Failed to get songs: %d -- %s",
+			this.failure = failure;
+			Log.e(TAG, String.format("Failed to get songs: %d -- %s",
 					failure.getStatusCode(), failure.getMessage()));
 		}
 		
 		@Override
 		public void onFinish() {
-			LOGD(TAG, String.format("Finished syncing songs (got %d songs).",
+			if (DIRECT_SQL) {
+				if (failure == null) db.setTransactionSuccessful();
+				db.endTransaction();
+				db.close();
+			}
+			Log.d(TAG, String.format("Finished syncing songs (got %d songs).",
 					songCount));
 		}
 	};
 	
 	private U1PlaylistListener mPlaylistListener = new U1PlaylistListener() {
+		private SQLiteDatabase db;
+		private PlaylistDao playlistDao = new PlaylistDao();
+		private Bundle progressBundle = new Bundle();
+		private Failure failure = null;
 		private int playlistCount = 0;
 		
-		private Bundle progressBundle = new Bundle();
-		
 		@Override
 		public void onStart() {
-			LOGD(TAG, "Syncing playlists...");
+			Log.d(TAG, "Syncing playlists...");
+			if (DIRECT_SQL) {
+				db = new MusicDatabase(SyncService.this).getWritableDatabase();
+				db.beginTransaction();
+			}
 			progressBundle.putInt(EXTRA_LOADER_ID, R.id.playlist_loader_id);
 		}
 		
 		@Override
 		public void onSuccess(U1Playlist playlist) {
 			playlistCount++;
-			ContentValues values = MusicContentValues.from(playlist);
-			Uri playlistUri = Playlists.buildPlaylistUri(playlist.getId());
-			int count = mResolver.update(playlistUri, values, null, null);
-			if (count == 0) {
-				mResolver.insert(Playlists.CONTENT_URI, values);
+			if (DIRECT_SQL) {
+				playlistDao.updateOrInsert(db, playlist);
+			} else {
+				playlistDao.updateOrInsert(mResolver, playlist);
 			}
 			mReceiver.send(SYNC_PROGRESS, progressBundle);
 		}
 
 		@Override
 		public void onFailure(Failure failure) {
-			super.onFailure(failure);
-			LOGE(TAG, String.format("Failed to get playlists: %d -- %s",
+			this.failure = failure;
+			Log.e(TAG, String.format("Failed to get playlists: %d -- %s",
 					failure.getStatusCode(), failure.getMessage()));
 		}
 		
 		@Override
 		public void onFinish() {
-			LOGD(TAG, String.format("Finished syncing playlists (got %d playlists).",
+			if (DIRECT_SQL) {
+				if (failure == null) db.setTransactionSuccessful();
+				db.endTransaction();
+				db.close();
+			}
+			Log.d(TAG, String.format("Finished syncing playlists (got %d playlists).",
 					playlistCount));
 		}
 	};
@@ -330,35 +377,46 @@
 	}
 	
 	private PlaylistSongListener mPlaylistSongListener = new PlaylistSongListener() {
+		private SQLiteDatabase db;
+		private PlaylistSongDao playlistSongDao = new PlaylistSongDao();
+		private Failure failure = null;
 		private int playlistSongCount = 0;
 		
 		@Override
 		public void onStart() {
 			playlistSongCount = 0; // This listener is reused, so reset.
-			LOGD(TAG, "Syncing playlist songs...");
+			Log.d(TAG, "Syncing playlist songs...");
+			if (DIRECT_SQL) {
+				db = new MusicDatabase(SyncService.this).getWritableDatabase();
+				db.beginTransaction();
+			}
 		}
 		
 		@Override
 		public void onSuccess(U1Song song) {
 			playlistSongCount++;
-			ContentValues values = MusicContentValues.from(mPlaylistId, song.getId());
-			Uri playlistSongsUri = Playlists.buildPlaylistSongUri(mPlaylistId, song.getId());
-			int count = mResolver.update(playlistSongsUri, values, null, null);
-			if (count == 0) {
-				mResolver.insert(playlistSongsUri, values);
+			if (DIRECT_SQL) {
+				playlistSongDao.updateOrInsert(db, mPlaylistId, song.getId());
+			} else {
+				playlistSongDao.updateOrInsert(mResolver, mPlaylistId, song);
 			}
 		}
 
 		@Override
 		public void onFailure(Failure failure) {
-			super.onFailure(failure);
-			LOGE(TAG, String.format("Failed to get playlist songs: %d -- %s",
+			this.failure = failure;
+			Log.e(TAG, String.format("Failed to get playlist songs: %d -- %s",
 					failure.getStatusCode(), failure.getMessage()));
 		}
 		
 		@Override
 		public void onFinish() {
-			LOGD(TAG, String.format("Finished syncing playlist songs (got %s playlist songs).",
+			if (DIRECT_SQL) {
+				if (failure == null) db.setTransactionSuccessful();
+				db.endTransaction();
+				db.close();
+			}
+			Log.d(TAG, String.format("Finished syncing playlist songs (got %s playlist songs).",
 					playlistSongCount));
 		}
 	};
 
=== modified file 'src/com/ubuntuone/android/music/ui/HomeActivity.java'
--- src/com/ubuntuone/android/music/ui/HomeActivity.java	2012-11-08 14:14:54 +0000
+++ src/com/ubuntuone/android/music/ui/HomeActivity.java	2012-11-21 17:34:22 +0000
@@ -192,7 +192,7 @@
 				mService.register(HomeActivity.this);
 			}
 		};
-		if (UbuntuOneMusic.DEBUG_SHOULD_BIND) {
+		if (UbuntuOneMusic.SHOULD_BIND) {
 			bindService(service, mConn, BIND_AUTO_CREATE | BIND_IMPORTANT);
 		}
 		
 
=== added file 'test/src/com/ubuntuone/android/music/UbuntuOneMusicTest.java'
--- test/src/com/ubuntuone/android/music/UbuntuOneMusicTest.java	1970-01-01 00:00:00 +0000
+++ test/src/com/ubuntuone/android/music/UbuntuOneMusicTest.java	2012-11-21 17:34:22 +0000
@@ -0,0 +1,10 @@
+package com.ubuntuone.android.music;
+
+import junit.framework.TestCase;
+
+public class UbuntuOneMusicTest extends TestCase
+{
+	public void testIsReleaseVersion() {
+		assertTrue("NOT a release version!", UbuntuOneMusic.IS_RELEASE);
+	}
+}
 
=== modified file 'test/src/com/ubuntuone/android/music/provider/MusicContentValuesTest.java'
--- test/src/com/ubuntuone/android/music/provider/MusicContentValuesTest.java	2012-11-13 13:58:31 +0000
+++ test/src/com/ubuntuone/android/music/provider/MusicContentValuesTest.java	2012-11-21 17:34:22 +0000
@@ -39,7 +39,7 @@
 		
 		final U1Artist u1Artist = new U1Artist(id, artistUrl, artist,
 				artistArtUrl, albumList, songCount);
-		final ContentValues cv = MusicContentValues.from(u1Artist);
+		final ContentValues cv = MusicContentValues.forArtist(u1Artist);
 		
 		assertEquals(id, cv.getAsString(Artists.ARTIST_ID));
 		assertEquals(artist, cv.getAsString(Artists.ARTIST_NAME));
@@ -63,7 +63,7 @@
 		
 		final U1Album u1Album = new U1Album(id, albumUrl, artist, artistId,
 				title, dateAdded, albumArtUrl, year);
-		final ContentValues cv = MusicContentValues.from(u1Album);
+		final ContentValues cv = MusicContentValues.forAlbum(u1Album);
 		
 		assertEquals(id, cv.getAsString(Albums.ALBUM_ID));
 		assertEquals(title, cv.getAsString(Albums.ALBUM_TITLE));
@@ -84,7 +84,7 @@
 		final String albumId = HashUtils.md5(title+artist);
 		final String artistId = HashUtils.md5(artist);
 		final String genre = "Dubstep";
-		final String genreIds = HashUtils.md5(genre.toUpperCase());
+		final String genreIds = MusicContentValues.getGenreId(genre);
 		final Integer year = 2012;
 		final Integer discNumber = 1;
 		final Integer track = 9;
@@ -105,7 +105,7 @@
 				album, songArtUrl, genre, year, discNumber, track,
 				duration, size, bitRate, artist, artistId, title, suffix,
 				contentType, songStreamUrl, path);
-		final ContentValues cv = MusicContentValues.from(u1Song);
+		final ContentValues cv = MusicContentValues.forSong(u1Song);
 		
 		assertEquals(id, cv.getAsString(Songs.SONG_ID));
 		assertEquals(title, cv.getAsString(Songs.SONG_TITLE));
@@ -141,7 +141,7 @@
 		
 		final U1Playlist u1Playlist = new U1Playlist(
 				id, playlistUrl, name, songCount);
-		final ContentValues cv = MusicContentValues.from(u1Playlist);
+		final ContentValues cv = MusicContentValues.forPlaylist(u1Playlist);
 		
 		assertEquals(id, cv.getAsString(Playlists.PLAYLIST_ID));
 		assertEquals(name, cv.getAsString(Playlists.PLAYLIST_NAME));
@@ -153,7 +153,7 @@
 		final String playlistId = "bc54b75b-0632-4438-b6a3-c90b83362562";
 		final String songId ="i6aVaQDYSS6Pal0GbO4MAw";
 		
-		final ContentValues cv = MusicContentValues.from(playlistId, songId);
+		final ContentValues cv = MusicContentValues.forPlaylistSong(playlistId, songId);
 		
 		assertEquals(playlistId, cv.getAsString(PlaylistSongs.PLAYLIST_ID));
 		assertEquals(songId, cv.getAsString(PlaylistSongs.SONG_ID));
@@ -161,9 +161,9 @@
 	
 	public void testFromGenre() {
 		final String genre = "Drum'n'Base";
-		final String genreId = HashUtils.md5(genre.toUpperCase());
+		final String genreId = MusicContentValues.getGenreId(genre);
 		
-		final ContentValues cv = MusicContentValues.fromGenre(genre);
+		final ContentValues cv = MusicContentValues.forGenre(genre);
 		
 		assertEquals(genreId, cv.getAsString(Genres.GENRE_ID));
 		assertEquals(genre, cv.getAsString(Genres.GENRE_TITLE));
 
=== modified file 'test/src/com/ubuntuone/android/music/provider/MusicProviderInsertTest.java'
--- test/src/com/ubuntuone/android/music/provider/MusicProviderInsertTest.java	2012-11-13 13:58:31 +0000
+++ test/src/com/ubuntuone/android/music/provider/MusicProviderInsertTest.java	2012-11-21 17:34:22 +0000
@@ -4,6 +4,7 @@
 
 import android.content.ContentValues;
 import android.database.Cursor;
+import android.database.sqlite.SQLiteDatabase;
 import android.net.Uri;
 
 import com.ubuntuone.android.music.provider.MusicContract.Albums;
@@ -13,6 +14,12 @@
 import com.ubuntuone.android.music.provider.MusicContract.Playlists;
 import com.ubuntuone.android.music.provider.MusicContract.Songs;
 import com.ubuntuone.android.music.provider.MusicContract.SongsColumns;
+import com.ubuntuone.android.music.provider.dao.AlbumDao;
+import com.ubuntuone.android.music.provider.dao.ArtistDao;
+import com.ubuntuone.android.music.provider.dao.GenreDao;
+import com.ubuntuone.android.music.provider.dao.PlaylistDao;
+import com.ubuntuone.android.music.provider.dao.PlaylistSongDao;
+import com.ubuntuone.android.music.provider.dao.SongDao;
 import com.ubuntuone.android.music.util.HashUtils;
 import com.ubuntuone.android.music.util.Lists;
 import com.ubuntuone.api.music.model.U1Album;
@@ -32,7 +39,7 @@
 		albumList.add("album6-album_id");
 		U1Artist artist = new U1Artist("artist3-artist_id", "artist3-artist_url",
 				"artist3-artist_name", "artist3-artist_art_url", albumList, 42);
-		ContentValues cv = MusicContentValues.from(artist);
+		ContentValues cv = MusicContentValues.forArtist(artist);
 		
 		Uri uri = mResolver.insert(Artists.CONTENT_URI, cv);
 		
@@ -42,13 +49,42 @@
 		assertEquals("Wrong artist row count returned.", 1, cursor.getCount());
 		assertTrue("Cursor missing rows.", cursor.moveToNext());
 		
-		assertEquals("Wrong artist id.", "artist3-artist_id",
-				cursor.getString(cursor.getColumnIndexOrThrow(Artists.ARTIST_ID)));
-		assertEquals("Wrong artist name.", "artist3-artist_name",
-				cursor.getString(cursor.getColumnIndexOrThrow(Artists.ARTIST_NAME)));
-		assertEquals("Wrong artist album.", "album5-album_id,album6-album_id",
-				cursor.getString(cursor.getColumnIndexOrThrow(Artists.ALBUM_LIST)));
-		assertEquals("Wrong artist song count.", 42,
+		assertEquals("Wrong artist id.", artist.getId(),
+				cursor.getString(cursor.getColumnIndexOrThrow(Artists.ARTIST_ID)));
+		assertEquals("Wrong artist name.", artist.getArtist(),
+				cursor.getString(cursor.getColumnIndexOrThrow(Artists.ARTIST_NAME)));
+		assertEquals("Wrong artist album.", MusicContentValues.getAlbumList(artist),
+				cursor.getString(cursor.getColumnIndexOrThrow(Artists.ALBUM_LIST)));
+		assertEquals("Wrong artist song count.", (int) artist.getSongCount(),
+				cursor.getInt(cursor.getColumnIndexOrThrow(Artists.SONG_COUNT)));
+		
+		cursor.close();
+	}
+	
+	public void testArtistDaoInsert() {
+		ArrayList<String> albumList = Lists.newArrayList();
+		albumList.add("album5-album_id");
+		albumList.add("album6-album_id");
+		U1Artist artist = new U1Artist("artist3-artist_id", "artist3-artist_url",
+				"artist3-artist_name", "artist3-artist_art_url", albumList, 42);
+		ArtistDao artistDao = new ArtistDao();
+		SQLiteDatabase db = new MusicDatabase(getMockContext()).getWritableDatabase();
+		artistDao.updateOrInsert(db, artist);
+		db.close();
+		
+		Uri uri = Artists.buildArtistUri(artist.getId());
+		
+		Cursor cursor = mResolver.query(uri, Artists.DEFAULT_PROJECTION, null, null, null);
+		assertEquals("Wrong artist row count returned.", 1, cursor.getCount());
+		assertTrue("Cursor missing rows.", cursor.moveToNext());
+
+		assertEquals("Wrong artist id.", artist.getId(),
+				cursor.getString(cursor.getColumnIndexOrThrow(Artists.ARTIST_ID)));
+		assertEquals("Wrong artist name.", artist.getArtist(),
+				cursor.getString(cursor.getColumnIndexOrThrow(Artists.ARTIST_NAME)));
+		assertEquals("Wrong artist album.", MusicContentValues.getAlbumList(artist),
+				cursor.getString(cursor.getColumnIndexOrThrow(Artists.ALBUM_LIST)));
+		assertEquals("Wrong artist song count.", (int) artist.getSongCount(),
 				cursor.getInt(cursor.getColumnIndexOrThrow(Artists.SONG_COUNT)));
 		
 		cursor.close();
@@ -57,7 +93,7 @@
 	public void testAlbumsInsert() {
 		U1Album album = new U1Album("album5-album_id", "album5-album_url", "artist1-artist_name",
 				"artist1-artist_id", "album5-album_title", 1345345345L, "album5-art-url", 2012);
-		ContentValues cv = MusicContentValues.from(album);
+		ContentValues cv = MusicContentValues.forAlbum(album);
 		
 		Uri uri = mResolver.insert(Albums.CONTENT_URI, cv);
 		
@@ -67,18 +103,47 @@
 		assertEquals("Wrong album row count returned.", 1, cursor.getCount());
 		assertTrue("Cursor missing rows.", cursor.moveToNext());
 		
-		assertEquals("Wrong album id.", "album5-album_id",
-				cursor.getString(cursor.getColumnIndexOrThrow(Albums.ALBUM_ID)));
-		assertEquals("Wrong album title.", "album5-album_title",
-				cursor.getString(cursor.getColumnIndexOrThrow(Albums.ALBUM_TITLE)));
-		assertEquals("Wrong album artist name.", "artist1-artist_name",
-				cursor.getString(cursor.getColumnIndexOrThrow(Albums.ALBUM_ARTIST)));
-		assertEquals("Wrong album artist id.",
-				HashUtils.md5("artist1-artist_name"),
-				cursor.getString(cursor.getColumnIndexOrThrow(Albums.ALBUM_ARTIST_ID)));
-		assertEquals("Wrong album year.", 2012,
-				cursor.getInt(cursor.getColumnIndexOrThrow(Albums.ALBUM_YEAR)));
-		assertEquals("Wrong album date added.", 1345345345L,
+		assertEquals("Wrong album id.", album.getId(),
+				cursor.getString(cursor.getColumnIndexOrThrow(Albums.ALBUM_ID)));
+		assertEquals("Wrong album title.", album.getTitle(),
+				cursor.getString(cursor.getColumnIndexOrThrow(Albums.ALBUM_TITLE)));
+		assertEquals("Wrong album artist name.", album.getArtist(),
+				cursor.getString(cursor.getColumnIndexOrThrow(Albums.ALBUM_ARTIST)));
+		assertEquals("Wrong album artist id.", album.getArtistId(),
+				cursor.getString(cursor.getColumnIndexOrThrow(Albums.ALBUM_ARTIST_ID)));
+		assertEquals("Wrong album year.", (int) album.getYear(),
+				cursor.getInt(cursor.getColumnIndexOrThrow(Albums.ALBUM_YEAR)));
+		assertEquals("Wrong album date added.", (long) album.getParsedDate(),
+				cursor.getLong(cursor.getColumnIndexOrThrow(Albums.ALBUM_DATE_ADDED)));
+		
+		cursor.close();
+	}
+	
+	public void testAlbumDaoInsert() {
+		U1Album album = new U1Album("album5-album_id", "album5-album_url", "artist1-artist_name",
+				"artist1-artist_id", "album5-album_title", 1345345345L, "album5-art-url", 2012);
+		AlbumDao albumDao = new AlbumDao();
+		SQLiteDatabase db = new MusicDatabase(getMockContext()).getWritableDatabase();
+		albumDao.updateOrInsert(db, album);
+		db.close();
+		
+		Uri uri = Albums.buildAlbumUri(album.getId());
+		
+		Cursor cursor = mResolver.query(uri, Albums.DEFAULT_PROJECTION, null, null, null);
+		assertEquals("Wrong album row count returned.", 1, cursor.getCount());
+		assertTrue("Cursor missing rows.", cursor.moveToNext());
+		
+		assertEquals("Wrong album id.", album.getId(),
+				cursor.getString(cursor.getColumnIndexOrThrow(Albums.ALBUM_ID)));
+		assertEquals("Wrong album title.", album.getTitle(),
+				cursor.getString(cursor.getColumnIndexOrThrow(Albums.ALBUM_TITLE)));
+		assertEquals("Wrong album artist name.", album.getArtist(),
+				cursor.getString(cursor.getColumnIndexOrThrow(Albums.ALBUM_ARTIST)));
+		assertEquals("Wrong album artist id.", album.getArtistId(),
+				cursor.getString(cursor.getColumnIndexOrThrow(Albums.ALBUM_ARTIST_ID)));
+		assertEquals("Wrong album year.", (int) album.getYear(),
+				cursor.getInt(cursor.getColumnIndexOrThrow(Albums.ALBUM_YEAR)));
+		assertEquals("Wrong album date added.", (long) album.getParsedDate(),
 				cursor.getLong(cursor.getColumnIndexOrThrow(Albums.ALBUM_DATE_ADDED)));
 		
 		cursor.close();
@@ -88,9 +153,9 @@
 		U1Song song = new U1Song("song5-song_id", "song5-song_url",
 				HashUtils.md5("album1-album_titleartist1-artist_name"), "song5-album_artist",
 				"album1-album_title", "song5-song_art_url", "genre2", 2009, 3, 2, 315,
-				1024 * 1024 * 2, 256, "artist1-artist_name", "aritst1-artist_id",
+				1024 * 1024 * 2, 256, "artist1-artist_name", HashUtils.md5("artist1-artist_name"),
 				"song5-song_title", "mp3", "audio/mpeg", "song5-song_stream", null);
-		ContentValues cv = MusicContentValues.from(song);
+		ContentValues cv = MusicContentValues.forSong(song);
 		
 		Uri uri = mResolver.insert(Songs.CONTENT_URI, cv);
 		
@@ -100,40 +165,96 @@
 		assertEquals("Wrong song row count returned.", 1, cursor.getCount());
 		assertTrue("Cursor missing rows.", cursor.moveToNext());
 		
-		assertEquals("Wrong song id.", "song5-song_id",
-				cursor.getString(cursor.getColumnIndexOrThrow(Songs.SONG_ID)));
-		assertEquals("Wrong song title.", "song5-song_title",
-				cursor.getString(cursor.getColumnIndexOrThrow(Songs.SONG_TITLE)));
-		assertEquals("Wrong song album.", "album1-album_title",
-				cursor.getString(cursor.getColumnIndexOrThrow(Songs.SONG_ALBUM)));
-		assertEquals("Wrong song album id.",
-				HashUtils.md5("album1-album_titleartist1-artist_name"),
-				cursor.getString(cursor.getColumnIndexOrThrow(Songs.SONG_ALBUM_ID)));
-		assertEquals("Wrong song album artist.", "song5-album_artist",
-				cursor.getString(cursor.getColumnIndexOrThrow(Songs.SONG_ALBUM_ARTIST)));
-		assertEquals("Wrong song artist.", "artist1-artist_name",
-				cursor.getString(cursor.getColumnIndexOrThrow(Songs.SONG_ARTIST)));
-		assertEquals("Wrong song artist id.", HashUtils.md5("artist1-artist_name"),
-				cursor.getString(cursor.getColumnIndexOrThrow(Songs.SONG_ARTIST_ID)));
-		assertEquals("Wrong song genre.", "genre2",
-				cursor.getString(cursor.getColumnIndexOrThrow(Songs.SONG_GENRE)));
-		assertEquals("Wrong song genre ids.", HashUtils.md5("genre2".toUpperCase()),
-				cursor.getString(cursor.getColumnIndexOrThrow(Songs.SONG_GENRE_ID)));
-		assertEquals("Wrong song year.", 2009,
-				cursor.getInt(cursor.getColumnIndexOrThrow(Songs.SONG_YEAR)));
-		assertEquals("Wrong song disc number.", 3,
-				cursor.getInt(cursor.getColumnIndexOrThrow(Songs.SONG_DISC_NUMBER)));
-		assertEquals("Wrong song track.", 2,
-				cursor.getInt(cursor.getColumnIndexOrThrow(Songs.SONG_TRACK)));
-		assertEquals("Wrong song duration.", 315,
-				cursor.getInt(cursor.getColumnIndexOrThrow(Songs.SONG_DURATION)));
-		assertEquals("Wrong song size.", 1024 * 1024 * 2,
-				cursor.getInt(cursor.getColumnIndexOrThrow(Songs.SONG_SIZE)));
-		assertEquals("Wrong song bit rate.", 256,
-				cursor.getInt(cursor.getColumnIndexOrThrow(Songs.SONG_BIT_RATE)));
-		assertEquals("Wrong song suffix.", "mp3",
-				cursor.getString(cursor.getColumnIndexOrThrow(Songs.SONG_SUFFIX)));
-		assertEquals("Wrong song content type.", "audio/mpeg",
+		assertEquals("Wrong song id.", song.getId(),
+				cursor.getString(cursor.getColumnIndexOrThrow(Songs.SONG_ID)));
+		assertEquals("Wrong song title.", song.getTitle(),
+				cursor.getString(cursor.getColumnIndexOrThrow(Songs.SONG_TITLE)));
+		assertEquals("Wrong song album.", song.getAlbum(),
+				cursor.getString(cursor.getColumnIndexOrThrow(Songs.SONG_ALBUM)));
+		assertEquals("Wrong song album id.", song.getAlbumId(),
+				cursor.getString(cursor.getColumnIndexOrThrow(Songs.SONG_ALBUM_ID)));
+		assertEquals("Wrong song album artist.", song.getAlbumArtist(),
+				cursor.getString(cursor.getColumnIndexOrThrow(Songs.SONG_ALBUM_ARTIST)));
+		assertEquals("Wrong song artist.", song.getArtist(),
+				cursor.getString(cursor.getColumnIndexOrThrow(Songs.SONG_ARTIST)));
+		assertEquals("Wrong song artist id.", song.getArtistId(),
+				cursor.getString(cursor.getColumnIndexOrThrow(Songs.SONG_ARTIST_ID)));
+		assertEquals("Wrong song genre.", song.getGenre(),
+				cursor.getString(cursor.getColumnIndexOrThrow(Songs.SONG_GENRE)));
+		assertEquals("Wrong song genre ids.", MusicContentValues.getGenreId(song.getGenre()),
+				cursor.getString(cursor.getColumnIndexOrThrow(Songs.SONG_GENRE_ID)));
+		assertEquals("Wrong song year.", (int) song.getYear(),
+				cursor.getInt(cursor.getColumnIndexOrThrow(Songs.SONG_YEAR)));
+		assertEquals("Wrong song disc number.", (int) song.getDiscNumber(),
+				cursor.getInt(cursor.getColumnIndexOrThrow(Songs.SONG_DISC_NUMBER)));
+		assertEquals("Wrong song track.", (int) song.getTrack(),
+				cursor.getInt(cursor.getColumnIndexOrThrow(Songs.SONG_TRACK)));
+		assertEquals("Wrong song duration.", (int) song.getDuration(),
+				cursor.getInt(cursor.getColumnIndexOrThrow(Songs.SONG_DURATION)));
+		assertEquals("Wrong song size.", (int) song.getSize(),
+				cursor.getInt(cursor.getColumnIndexOrThrow(Songs.SONG_SIZE)));
+		assertEquals("Wrong song bit rate.", (int) song.getBitRate(),
+				cursor.getInt(cursor.getColumnIndexOrThrow(Songs.SONG_BIT_RATE)));
+		assertEquals("Wrong song suffix.", song.getSuffix(),
+				cursor.getString(cursor.getColumnIndexOrThrow(Songs.SONG_SUFFIX)));
+		assertEquals("Wrong song content type.", song.getContentType(),
+				cursor.getString(cursor.getColumnIndexOrThrow(Songs.SONG_CONTENT_TYPE)));
+		assertEquals("Wrong song last played at.", 0L,
+				cursor.getLong(cursor.getColumnIndexOrThrow(Songs.SONG_LAST_PLAYED_AT)));
+		
+		cursor.close();
+	}
+	
+	public void testSongDaoInsert() {
+		U1Song song = new U1Song("song5-song_id", "song5-song_url",
+				HashUtils.md5("album1-album_titleartist1-artist_name"), "song5-album_artist",
+				"album1-album_title", "song5-song_art_url", "genre2", 2009, 3, 2, 315,
+				1024 * 1024 * 2, 256, "artist1-artist_name", HashUtils.md5("artist1-artist_name"),
+				"song5-song_title", "mp3", "audio/mpeg", "song5-song_stream", null);
+		SongDao songDao = new SongDao();
+		SQLiteDatabase db = new MusicDatabase(getMockContext()).getWritableDatabase();
+		songDao.updateOrInsert(db, song);
+		db.close();
+		
+		Uri uri = Songs.buildSongUri(song.getId());
+		
+		Cursor cursor = mResolver.query(uri, Songs.DEFAULT_PROJECTION, null, null, null);
+		assertEquals("Wrong song row count returned.", 1, cursor.getCount());
+		assertTrue("Cursor missing rows.", cursor.moveToNext());
+		
+		assertEquals("Wrong song id.", song.getId(),
+				cursor.getString(cursor.getColumnIndexOrThrow(Songs.SONG_ID)));
+		assertEquals("Wrong song title.", song.getTitle(),
+				cursor.getString(cursor.getColumnIndexOrThrow(Songs.SONG_TITLE)));
+		assertEquals("Wrong song album.", song.getAlbum(),
+				cursor.getString(cursor.getColumnIndexOrThrow(Songs.SONG_ALBUM)));
+		assertEquals("Wrong song album id.", song.getAlbumId(),
+				cursor.getString(cursor.getColumnIndexOrThrow(Songs.SONG_ALBUM_ID)));
+		assertEquals("Wrong song album artist.", song.getAlbumArtist(),
+				cursor.getString(cursor.getColumnIndexOrThrow(Songs.SONG_ALBUM_ARTIST)));
+		assertEquals("Wrong song artist.", song.getArtist(),
+				cursor.getString(cursor.getColumnIndexOrThrow(Songs.SONG_ARTIST)));
+		assertEquals("Wrong song artist id.", song.getArtistId(),
+				cursor.getString(cursor.getColumnIndexOrThrow(Songs.SONG_ARTIST_ID)));
+		assertEquals("Wrong song genre.", song.getGenre(),
+				cursor.getString(cursor.getColumnIndexOrThrow(Songs.SONG_GENRE)));
+		assertEquals("Wrong song genre ids.", MusicContentValues.getGenreId(song.getGenre()),
+				cursor.getString(cursor.getColumnIndexOrThrow(Songs.SONG_GENRE_ID)));
+		assertEquals("Wrong song year.", (int) song.getYear(),
+				cursor.getInt(cursor.getColumnIndexOrThrow(Songs.SONG_YEAR)));
+		assertEquals("Wrong song disc number.", (int) song.getDiscNumber(),
+				cursor.getInt(cursor.getColumnIndexOrThrow(Songs.SONG_DISC_NUMBER)));
+		assertEquals("Wrong song track.", (int) song.getTrack(),
+				cursor.getInt(cursor.getColumnIndexOrThrow(Songs.SONG_TRACK)));
+		assertEquals("Wrong song duration.", (int) song.getDuration(),
+				cursor.getInt(cursor.getColumnIndexOrThrow(Songs.SONG_DURATION)));
+		assertEquals("Wrong song size.", (int) song.getSize(),
+				cursor.getInt(cursor.getColumnIndexOrThrow(Songs.SONG_SIZE)));
+		assertEquals("Wrong song bit rate.", (int) song.getBitRate(),
+				cursor.getInt(cursor.getColumnIndexOrThrow(Songs.SONG_BIT_RATE)));
+		assertEquals("Wrong song suffix.", song.getSuffix(),
+				cursor.getString(cursor.getColumnIndexOrThrow(Songs.SONG_SUFFIX)));
+		assertEquals("Wrong song content type.", song.getContentType(),
 				cursor.getString(cursor.getColumnIndexOrThrow(Songs.SONG_CONTENT_TYPE)));
 		assertEquals("Wrong song last played at.", 0L,
 				cursor.getLong(cursor.getColumnIndexOrThrow(Songs.SONG_LAST_PLAYED_AT)));
@@ -144,7 +265,7 @@
 	public void testPlaylistsInsert() {
 		U1Playlist playlist = new U1Playlist("playlist3-playlist_id", "playlist3-playlist_url",
 				"playlist3-playlist_name", 10);
-		ContentValues cv = MusicContentValues.from(playlist);
+		ContentValues cv = MusicContentValues.forPlaylist(playlist);
 		
 		Uri uri = mResolver.insert(Playlists.CONTENT_URI, cv);
 		
@@ -154,18 +275,44 @@
 		assertEquals("Wrong playlist row count returned.", 1, cursor.getCount());
 		assertTrue("Cursor missing rows.", cursor.moveToNext());
 		
-		assertEquals("Wrong playlist id.", "playlist3-playlist_id",
-				cursor.getString(cursor.getColumnIndexOrThrow(Playlists.PLAYLIST_ID)));
-		assertEquals("Wrong playlist name.", "playlist3-playlist_name",
-				cursor.getString(cursor.getColumnIndexOrThrow(Playlists.PLAYLIST_NAME)));
-		assertEquals("Wrong playlist song count.", 10,
+		assertEquals("Wrong playlist id.", playlist.getId(),
+				cursor.getString(cursor.getColumnIndexOrThrow(Playlists.PLAYLIST_ID)));
+		assertEquals("Wrong playlist name.", playlist.getName(),
+				cursor.getString(cursor.getColumnIndexOrThrow(Playlists.PLAYLIST_NAME)));
+		assertEquals("Wrong playlist song count.", (int) playlist.getSongCount(),
+				cursor.getInt(cursor.getColumnIndexOrThrow(Playlists.PLAYLIST_SONG_COUNT)));
+		
+		cursor.close();
+	}
+	
+	public void testPlaylistDaoInsert() {
+		U1Playlist playlist = new U1Playlist("playlist3-playlist_id", "playlist3-playlist_url",
+				"playlist3-playlist_name", 10);
+		PlaylistDao playlistDao = new PlaylistDao();
+		SQLiteDatabase db = new MusicDatabase(getMockContext()).getWritableDatabase();
+		playlistDao.updateOrInsert(db, playlist);
+		db.close();
+		
+		Uri uri = Playlists.buildPlaylistUri(playlist.getId());
+		
+		Cursor cursor = mResolver.query(uri, Playlists.DEFAULT_PROJECTION, null, null, null);
+		assertEquals("Wrong playlist row count returned.", 1, cursor.getCount());
+		assertTrue("Cursor missing rows.", cursor.moveToNext());
+		
+		assertEquals("Wrong playlist id.", playlist.getId(),
+				cursor.getString(cursor.getColumnIndexOrThrow(Playlists.PLAYLIST_ID)));
+		assertEquals("Wrong playlist name.", playlist.getName(),
+				cursor.getString(cursor.getColumnIndexOrThrow(Playlists.PLAYLIST_NAME)));
+		assertEquals("Wrong playlist song count.", (int) playlist.getSongCount(),
 				cursor.getInt(cursor.getColumnIndexOrThrow(Playlists.PLAYLIST_SONG_COUNT)));
 		
 		cursor.close();
 	}
 	
 	public void testPlaylistSongsInsert() {
-		Uri playlistSongsUri = Playlists.buildPlaylistSongsUri("playlist1-playlist_id");
+		final String playlistId = "playlist1-playlist_id";
+		final String songId = "song3-song_id";
+		Uri playlistSongsUri = Playlists.buildPlaylistSongsUri(playlistId);
 		
 		{ // Check preconditions.
 			Cursor cursor = mResolver.query(playlistSongsUri, PlaylistSongs.DEFAULT_PROJECTION,
@@ -175,7 +322,7 @@
 		}
 		
 		// Insert new song.
-		ContentValues cv = MusicContentValues.from("playlist1-playlist_id", "song3-song_id");
+		ContentValues cv = MusicContentValues.forPlaylistSong(playlistId, songId);
 		Uri uri = mResolver.insert(playlistSongsUri, cv);
 		
 		assertNotNull("Inserted playlist song uri is null.", uri);
@@ -186,9 +333,41 @@
 		
 		assertTrue("Cursor missing rows.", cursor.moveToPosition(2)); // move to third song
 		
-		assertEquals("Wrong playlist id.", "playlist1-playlist_id",
-				cursor.getString(cursor.getColumnIndexOrThrow(PlaylistSongs.PLAYLIST_ID)));
-		assertEquals("Wrong playlist song id.", "song3-song_id",
+		assertEquals("Wrong playlist id.", playlistId,
+				cursor.getString(cursor.getColumnIndexOrThrow(PlaylistSongs.PLAYLIST_ID)));
+		assertEquals("Wrong playlist song id.", songId,
+				cursor.getString(cursor.getColumnIndexOrThrow(SongsColumns.SONG_ID)));
+		
+		cursor.close();
+	}
+	
+	public void testPlaylistSongDaoInsert() {
+		final String playlistId = "playlist1-playlist_id";
+		final String songId = "song3-song_id";
+		Uri playlistSongsUri = Playlists.buildPlaylistSongsUri(playlistId);
+		
+		{ // Check preconditions.
+			Cursor cursor = mResolver.query(playlistSongsUri, PlaylistSongs.DEFAULT_PROJECTION,
+					null, null, PlaylistSongs.DEFAULT_SORT);
+			assertEquals("Wrong playlist song row count returned.", 2, cursor.getCount());
+			cursor.close();
+		}
+		
+		// Insert new song.
+		PlaylistSongDao playlistSongDao = new PlaylistSongDao();
+		SQLiteDatabase db = new MusicDatabase(getMockContext()).getWritableDatabase();
+		playlistSongDao.updateOrInsert(db, playlistId, songId);
+		db.close();
+		
+		Cursor cursor = mResolver.query(playlistSongsUri, PlaylistSongs.DEFAULT_PROJECTION,
+				null, null, PlaylistSongs.DEFAULT_SORT);
+		assertEquals("Wrong playlist song row count returned.", 3, cursor.getCount());
+		
+		assertTrue("Cursor missing rows.", cursor.moveToPosition(2)); // move to third song
+		
+		assertEquals("Wrong playlist id.", playlistId,
+				cursor.getString(cursor.getColumnIndexOrThrow(PlaylistSongs.PLAYLIST_ID)));
+		assertEquals("Wrong playlist song id.", songId,
 				cursor.getString(cursor.getColumnIndexOrThrow(SongsColumns.SONG_ID)));
 		
 		cursor.close();
@@ -199,11 +378,11 @@
 		String genre1 = "acid jazz";
 		String genre2 = "Acid JAZZ";
 		
-		ContentValues cv1 = MusicContentValues.fromGenre(genre1);
+		ContentValues cv1 = MusicContentValues.forGenre(genre1);
 		Uri uri = mResolver.insert(Genres.CONTENT_URI, cv1);
 		assertNotNull("Inserted genre uri is null.", uri);
 		
-		ContentValues cv2 = MusicContentValues.fromGenre(genre2);
+		ContentValues cv2 = MusicContentValues.forGenre(genre2);
 		Uri uri2 = mResolver.insert(Genres.CONTENT_URI, cv2);
 		assertNotNull("Inserted genre uri is null.", uri2);
 		
@@ -213,7 +392,28 @@
 		assertEquals("Wrong genre row count returned.", 1, cursor.getCount());
 		assertTrue("Cursor missing rows.", cursor.moveToNext());
 		
-		assertEquals("Wrong genre name.", "acid jazz",
+		assertEquals("Wrong genre name.", genre1,
+				cursor.getString(cursor.getColumnIndexOrThrow(Genres.GENRE_TITLE)));
+	}
+	
+	public void testGenreDaoInsert() {
+		// These genres are treated as same: md5(genre.toUpperCase())
+		String genre1 = "acid jazz";
+		String genre2 = "Acid JAZZ";
+		
+		GenreDao genreDao = new GenreDao();
+		SQLiteDatabase db = new MusicDatabase(getMockContext()).getWritableDatabase();
+		genreDao.updateOrInsert(db, genre1);
+		genreDao.updateOrInsert(db, genre2);
+		db.close();
+		
+		Cursor cursor = mResolver.query(Genres.CONTENT_URI,
+				Genres.DEFAULT_PROJECTION, null, null, null);
+				
+		assertEquals("Wrong genre row count returned.", 1, cursor.getCount());
+		assertTrue("Cursor missing rows.", cursor.moveToNext());
+		
+		assertEquals("Wrong genre name.", genre1,
 				cursor.getString(cursor.getColumnIndexOrThrow(Genres.GENRE_TITLE)));
 	}
 }