Merge lp:~karni/ubuntuone-android-music/v2-cache-settings into lp:ubuntuone-android-music/v2

[Michał Karnicki]

Added cache preferences.

Added storage utility class providing storage related info.
Added custom seek bar preference.
Added tablet ready preference activity.
Implemented cache: storage, size and cleaning preferences.
Misc tiny changes I allowed myself to add in small, separate commits.

[Diego Sarmentero (diegosarmentero)]

+1

review: Approve

=== modified file 'main/AndroidManifest.xml'
--- main/AndroidManifest.xml	2013-01-23 02:37:15 +0000
+++ main/AndroidManifest.xml	2013-01-25 16:20:29 +0000
@@ -1,19 +1,17 @@
 <?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
     package="com.ubuntuone.android.music"
+    android:sharedUserId="com.ubuntu.one"
+    android:sharedUserLabel="@string/shared_user"
     android:versionCode="1"
     android:versionName="0.1.0" >
 
-    <!--
-    FIXME Set shared user id:
-    android:sharedUserId="com.ubuntuone.android"
-    android:sharedUserLabel="@string/shared_user"
-    -->
     <uses-sdk
         android:minSdkVersion="10"
         android:targetSdkVersion="14" />
 
     <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
     <uses-permission android:name="android.permission.GET_ACCOUNTS" />
     <uses-permission android:name="android.permission.INTERNET" />
     <uses-permission android:name="android.permission.READ_PHONE_STATE" />
@@ -23,6 +21,7 @@
 
     <application
         android:name=".UbuntuOneMusic"
+        android:allowBackup="false"
         android:label="@string/app_name"
         android:theme="@style/Theme.Sherlock.Light"
         android:uiOptions="splitActionBarWhenNarrow" >
@@ -75,8 +74,8 @@
             android:screenOrientation="portrait" >
         </activity>
         <activity
-            android:name=".ui.SettingsActivity"
-            android:label="U1 Music Settings"
+            android:name=".ui.PreferencesActivity"
+            android:label="Ubuntu One Music Settings"
             android:theme="@style/Theme.Sherlock.Light" >
         </activity>
 
@@ -95,8 +94,8 @@
 
         <provider
             android:name=".provider.MusicProvider"
+            android:authorities="com.ubuntuone.android.music"
             android:exported="false"
-            android:authorities="com.ubuntuone.android.music"
             android:label="@string/app_name"
             android:syncable="true"
             android:writePermission="com.ubuntuone.android.music.permission.WRITE_MUSIC_DATA" />
 
=== added file 'main/res/layout/activity_preferences.xml'
--- main/res/layout/activity_preferences.xml	1970-01-01 00:00:00 +0000
+++ main/res/layout/activity_preferences.xml	2013-01-25 16:20:29 +0000
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:orientation="horizontal" >
+
+    <fragment
+        android:id="@+id/settings_fragment"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        class="com.ubuntuone.android.music.ui.SettingsFragment" />
+
+</LinearLayout>
 \ No newline at end of file
 
=== added file 'main/res/layout/seek_bar_preference.xml'
--- main/res/layout/seek_bar_preference.xml	1970-01-01 00:00:00 +0000
+++ main/res/layout/seek_bar_preference.xml	2013-01-25 16:20:29 +0000
@@ -0,0 +1,54 @@
+<?xml version="1.0" encoding="utf-8"?>
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:id="@android:id/widget_frame"
+    android:layout_width="fill_parent"
+    android:layout_height="wrap_content"
+    android:layout_marginBottom="6dp"
+    android:layout_marginLeft="15dp"
+    android:layout_marginRight="6dp"
+    android:layout_marginTop="6dp"
+    android:gravity="center_vertical"
+    android:minHeight="?android:attr/listPreferredItemHeight"
+    android:paddingLeft="8dp"
+    android:paddingRight="?android:attr/scrollbarSize" >
+
+    <TextView
+        android:id="@android:id/title"
+        android:layout_width="fill_parent"
+        android:layout_height="wrap_content"
+        android:layout_alignParentLeft="true"
+        android:layout_alignParentTop="true"
+        android:ellipsize="marquee"
+        android:fadingEdge="horizontal"
+        android:singleLine="true"
+        android:textAppearance="?android:attr/textAppearanceMedium" />
+
+    <TextView
+        android:id="@android:id/summary"
+        android:layout_width="fill_parent"
+        android:layout_height="wrap_content"
+        android:layout_alignParentLeft="true"
+        android:layout_below="@android:id/title"
+        android:textAppearance="?android:attr/textAppearanceSmall"
+        android:textColor="?android:attr/textColorSecondary" />
+
+    <TextView
+        android:id="@+id/seekBarPrefValue"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_below="@android:id/title"
+        android:layout_alignParentRight="true"
+        android:gravity="right"
+        android:textAppearance="?android:attr/textAppearanceSmall"
+        android:textColor="?android:attr/textColorSecondary" />
+
+    <LinearLayout
+        android:id="@+id/seekBarPrefBarContainer"
+        android:layout_width="fill_parent"
+        android:layout_height="wrap_content"
+        android:layout_alignParentBottom="true"
+        android:layout_alignParentLeft="true"
+        android:layout_below="@android:id/summary" >
+    </LinearLayout>
+
+</RelativeLayout>
 \ No newline at end of file
 
=== added directory 'main/res/xml'
=== added file 'main/res/xml/preference_headers.xml'
--- main/res/xml/preference_headers.xml	1970-01-01 00:00:00 +0000
+++ main/res/xml/preference_headers.xml	2013-01-25 16:20:29 +0000
@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="utf-8"?>
+<preference-headers xmlns:android="http://schemas.android.com/apk/res/android" >
+
+    <header
+        android:fragment="com.ubuntuone.android.music.ui.PreferencesActivity$PreferencesFragment"
+        android:icon="@android:drawable/ic_menu_help"
+        android:summary="(placeholder item)"
+        android:title="Account" >
+        <extra
+            android:name="preferenceResource"
+            android:value="preferences_account" />
+    </header>
+    <header
+        android:fragment="com.ubuntuone.android.music.ui.PreferencesActivity$PreferencesFragment"
+        android:icon="@android:drawable/ic_menu_manage"
+        android:summary="Manage used space"
+        android:title="Cache" >
+        <extra
+            android:name="preferenceResource"
+            android:value="preferences_cache" />
+    </header>
+    <header
+        android:icon="@android:drawable/ic_menu_agenda"
+        android:summary="(placeholder item)"
+        android:title="Ubuntu One Blog" >
+        <intent
+            android:action="android.intent.action.VIEW"
+            android:data="https://one.ubuntu.com/blog" />
+    </header>
+
+</preference-headers>
 \ No newline at end of file
 
=== added file 'main/res/xml/preferences_account.xml'
--- main/res/xml/preferences_account.xml	1970-01-01 00:00:00 +0000
+++ main/res/xml/preferences_account.xml	2013-01-25 16:20:29 +0000
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<PreferenceScreen xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:ubuntuone="http://schemas.one.ubuntu.com/apk/res/android"
+    android:key="preference_screen" >
+
+</PreferenceScreen>
 \ No newline at end of file
 
=== added file 'main/res/xml/preferences_cache.xml'
--- main/res/xml/preferences_cache.xml	1970-01-01 00:00:00 +0000
+++ main/res/xml/preferences_cache.xml	2013-01-25 16:20:29 +0000
@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="utf-8"?>
+<PreferenceScreen xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:ubuntuone="http://schemas.one.ubuntu.com/apk/res/android"
+    android:key="preference_screen" >
+
+    <PreferenceCategory
+        android:key="preferenceCategory"
+        android:title="Cache" >
+        <ListPreference
+            android:key="cacheLocation"
+            android:persistent="true"
+            android:title="Storage" />
+
+        <com.ubuntuone.android.music.util.SeekBarPreference
+            android:key="cacheSize"
+            android:persistent="true"
+            android:summary="Adjust allowed space"
+            android:title="Size" />
+
+        <Preference
+            android:key="clearCache"
+            android:summary="Deletes non-favorite songs"
+            android:title="Clear non-favorites" />
+    </PreferenceCategory>
+
+</PreferenceScreen>
 \ No newline at end of file
 
=== added file 'main/src/com/ubuntuone/android/music/Constants.java'
--- main/src/com/ubuntuone/android/music/Constants.java	1970-01-01 00:00:00 +0000
+++ main/src/com/ubuntuone/android/music/Constants.java	2013-01-25 16:20:29 +0000
@@ -0,0 +1,10 @@
+package com.ubuntuone.android.music;
+
+public class Constants {
+	public static interface Preference {
+		String CACHE_LOCATION_KEY = "cacheLocation";
+		String CACHE_DIR_KEY = "cacheDir";
+		String CACHE_SIZE_KEY = "cacheSize";
+		String CLEAR_CACHE_KEY = "clearCache";
+	}
+}
 
=== modified file 'main/src/com/ubuntuone/android/music/UbuntuOneMusic.java'
--- main/src/com/ubuntuone/android/music/UbuntuOneMusic.java	2013-01-23 02:36:20 +0000
+++ main/src/com/ubuntuone/android/music/UbuntuOneMusic.java	2013-01-25 16:20:29 +0000
@@ -37,6 +37,7 @@
 import com.ubuntuone.android.music.util.HttpManager;
 import com.ubuntuone.android.music.util.Log;
 import com.ubuntuone.android.music.util.NotAuthenticatedException;
+import com.ubuntuone.android.music.util.StorageUtils;
 import com.ubuntuone.api.music.U1MusicAPI;
 import com.ubuntuone.api.sso.authorizer.OAuthAuthorizer;
 
@@ -67,6 +68,8 @@
 		super.onCreate();
 		instance = this;
 		setupLogging();
+		
+		StorageUtils.setupMusicDirectory(this);
 	}
 
 	private void setupLogging() {
 
=== modified file 'main/src/com/ubuntuone/android/music/provider/MusicProviderUtils.java'
--- main/src/com/ubuntuone/android/music/provider/MusicProviderUtils.java	2012-12-14 04:29:46 +0000
+++ main/src/com/ubuntuone/android/music/provider/MusicProviderUtils.java	2013-01-25 16:20:29 +0000
@@ -206,7 +206,25 @@
 		String selection = Songs.SONG_PATH + " IS NOT NULL";
 		return getSongCount(context, selection);
 	}
-	
+
+	public static long getCachedSongSize(Context context) {
+		ContentResolver resolver = context.getContentResolver();
+		String[] projection = new String[] {
+				"SUM(" + Songs.SONG_SIZE + ") as cache_size_used"
+			}; 
+		Cursor cursor = null;
+		long size = 0;
+		try {
+			cursor = resolver.query(Songs.CACHED_SONGS_URI, projection, null, null, null);
+			if (cursor != null && cursor.moveToFirst()) {
+				size = cursor.getLong(cursor.getColumnIndex("cache_size_used"));
+			}
+		} finally {
+			if (cursor != null) cursor.close();
+		}
+		return size;
+	}
+
 	public static int getPlaylistSongCount(Context context, Uri playlistUri) {
 		ContentResolver resolver = context.getContentResolver();
 		String playlistId = Playlists.getPlaylistId(playlistUri);
 
=== modified file 'main/src/com/ubuntuone/android/music/service/MusicServiceSupport.java'
--- main/src/com/ubuntuone/android/music/service/MusicServiceSupport.java	2012-12-14 04:29:46 +0000
+++ main/src/com/ubuntuone/android/music/service/MusicServiceSupport.java	2013-01-25 16:20:29 +0000
@@ -56,6 +56,7 @@
 	private MusicService mMusicService;
 	private BroadcastReceiver mHeadsetBroadcastReceiver;
 	private PhoneStateListener mPhoneStateListener;
+	private boolean mWasOnCreateCalled = false;
 	
 	public MusicServiceSupport(MusicService service) {
 		this.mMusicService = service;
@@ -64,6 +65,7 @@
 	}
 	
 	public void onCreate() {
+		mWasOnCreateCalled = true;
 		registerHeadsetBroadcastReceiver();
 		registerMediaButtonBroadcastReceiver();
 		registerPhoneStateListener();
@@ -79,6 +81,9 @@
 	}
 	
 	public void onDestroy() {
+		if (!mWasOnCreateCalled) {
+			return;
+		}
 		unregisterHeadsetBroadcastReceiver();
 		unregisterMediaButtonBroadcastReceiver();
 		unregisterPhoneStateListener();
 
=== modified file 'main/src/com/ubuntuone/android/music/ui/HomeActivity.java'
--- main/src/com/ubuntuone/android/music/ui/HomeActivity.java	2013-01-23 02:36:20 +0000
+++ main/src/com/ubuntuone/android/music/ui/HomeActivity.java	2013-01-25 16:20:29 +0000
@@ -419,7 +419,7 @@
 	}
 	
 	private boolean onSettingsOptionItemSelected() {
-		Intent settingsIntent = new Intent(this, SettingsActivity.class);
+		Intent settingsIntent = new Intent(this, PreferencesActivity.class);
 		startActivity(settingsIntent);
 		return true;
 	}
 
=== added file 'main/src/com/ubuntuone/android/music/ui/PreferencesActivity.java'
--- main/src/com/ubuntuone/android/music/ui/PreferencesActivity.java	1970-01-01 00:00:00 +0000
+++ main/src/com/ubuntuone/android/music/ui/PreferencesActivity.java	2013-01-25 16:20:29 +0000
@@ -0,0 +1,269 @@
+/*
+ * Ubuntu One Music - stream music from Ubuntu One cloud storage.
+ * 
+ * Copyright 2012-2013 Canonical Ltd.
+ * 
+ * This file is part of Ubuntu One Music app.
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see http://www.gnu.org/licenses 
+ */
+
+package com.ubuntuone.android.music.ui;
+
+import static com.ubuntuone.android.music.util.LogUtils.makeLogTag;
+import static com.ubuntuone.android.music.util.StorageUtils.MiB;
+
+import java.io.File;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.Arrays;
+import java.util.List;
+
+import android.annotation.TargetApi;
+import android.content.ContentResolver;
+import android.content.ContentValues;
+import android.content.Context;
+import android.database.Cursor;
+import android.net.Uri;
+import android.os.AsyncTask;
+import android.os.Build;
+import android.os.Bundle;
+import android.preference.ListPreference;
+import android.preference.Preference;
+import android.preference.Preference.OnPreferenceChangeListener;
+import android.preference.Preference.OnPreferenceClickListener;
+import android.preference.PreferenceActivity;
+import android.preference.PreferenceFragment;
+import android.preference.PreferenceManager;
+import android.util.Log;
+import android.widget.Toast;
+
+import com.ubuntuone.android.music.Constants;
+import com.ubuntuone.android.music.R;
+import com.ubuntuone.android.music.provider.MusicContract.Songs;
+import com.ubuntuone.android.music.provider.MusicProviderUtils;
+import com.ubuntuone.android.music.util.SeekBarPreference;
+import com.ubuntuone.android.music.util.StorageUtils;
+import com.ubuntuone.android.music.util.StorageUtils.InvalidStorage;
+import com.ubuntuone.android.music.util.UIUtils;
+ 
+public class PreferencesActivity extends PreferenceActivity implements OnPreferenceClickListener {
+	private static final String TAG = makeLogTag(PreferencesActivity.class.getSimpleName());
+	
+	protected Method mLoadHeaders = null;
+	protected Method mHasHeaders = null;
+	protected boolean mIsTablet;
+	
+	protected ClearCacheTask mClearCacheTask;
+
+	public boolean hasHeadersCompat() {
+		if (mHasHeaders != null && mLoadHeaders != null) {
+			try {
+				return (Boolean) mHasHeaders.invoke(this);
+			} catch (IllegalArgumentException e) {
+			} catch (IllegalAccessException e) {
+			} catch (InvocationTargetException e) {
+			}
+		}
+		return false;
+	}
+
+	@SuppressWarnings("deprecation")
+	@Override
+	public void onCreate(Bundle aSavedState) {
+		// onBuildHeaders() will be called during super.onCreate()
+		try {
+			mLoadHeaders = getClass().getMethod("loadHeadersFromResource", int.class, List.class);
+			mHasHeaders = getClass().getMethod("hasHeaders");
+		} catch (NoSuchMethodException e) {
+			// We're handling an old API.
+		}
+		mIsTablet = UIUtils.isTablet(this);
+		super.onCreate(aSavedState);
+		if (!hasHeadersCompat() || !mIsTablet) {
+			addPreferencesFromResource(R.xml.preferences_account);
+			addPreferencesFromResource(R.xml.preferences_cache);
+		}
+		
+		setupCacheLocationPreference();
+		setupCacheSizePreference(this);
+		setupClearCachePreference(this);
+	}
+
+	@Override
+	public void onBuildHeaders(List<Header> target) {
+		try {
+			if (mIsTablet) {
+				mLoadHeaders.invoke(this, new Object[] { R.xml.preference_headers, target });
+			}
+		} catch (IllegalArgumentException e) {
+		} catch (IllegalAccessException e) {
+		} catch (InvocationTargetException e) {
+		}
+	}
+
+	@TargetApi(Build.VERSION_CODES.HONEYCOMB)
+	static public class PreferencesFragment extends PreferenceFragment {
+		@Override
+		public void onCreate(Bundle savedInstanceState) {
+			super.onCreate(savedInstanceState);
+			Context context = getActivity().getApplicationContext();
+			int preferencesResource = context.getResources().getIdentifier(
+					getArguments().getString("preferenceResource"), "xml",
+					context.getPackageName());
+			PreferenceManager.setDefaultValues(context, preferencesResource, false);
+			addPreferencesFromResource(preferencesResource);
+			// Hack. On tablets, hide the category title duplicated in fragment title.
+			findPreference("preferenceCategory").setTitle("");
+		}
+	}
+	
+	public void setupCacheLocationPreference() {
+		@SuppressWarnings("deprecation")
+		final ListPreference cacheLocation = (ListPreference) findPreference(
+				Constants.Preference.CACHE_LOCATION_KEY);
+		final String[] storagePaths = StorageUtils.getAvailableStoragePaths();
+		Log.i(TAG, "Available storage paths: " + Arrays.toString(storagePaths));
+		if (storagePaths != null) {
+			cacheLocation.setEntries(storagePaths);
+			cacheLocation.setEntryValues(storagePaths);
+			
+			String storage = cacheLocation.getValue();
+			cacheLocation.setValue(storage);
+			cacheLocation.setSummary(storage);
+			try {
+				int index = StorageUtils.getSelectedStorageIndex(storage, storagePaths);
+				cacheLocation.setValueIndex(index);
+			} catch (InvalidStorage e) {
+				// Should not happen, as the value has been already set.
+			}
+			
+			cacheLocation.setOnPreferenceChangeListener(new OnPreferenceChangeListener() {
+				@Override
+				public boolean onPreferenceChange(Preference preference, Object newValue) {
+					// TODO karni: Move cached music to new location or at least notify the user.
+					String location = (String) newValue;
+					cacheLocation.setSummary(location);
+					return true;
+				}
+			});
+		} else {
+			cacheLocation.setEnabled(false);
+		}
+	}
+	
+	public void setupCacheSizePreference(Context context) {
+		@SuppressWarnings("deprecation")
+		SeekBarPreference seekBarPreference = (SeekBarPreference) findPreference(
+				Constants.Preference.CACHE_SIZE_KEY);
+		String storage = StorageUtils.getMusicDirectory(context);
+
+		long cacheSize = MusicProviderUtils.getCachedSongSize(context);
+		long min = Math.max(StorageUtils.MIN_CACHE_SIZE, cacheSize);
+		long max = StorageUtils.getAvailableStorage(context, storage) - cacheSize;
+
+		seekBarPreference.setMinValue((int)(min / MiB));
+		seekBarPreference.setMaxValue((int)(max / MiB));
+		seekBarPreference.setDefaultValue((int)(max / MiB));
+	}
+	
+	public void setupClearCachePreference(Context context) {
+		@SuppressWarnings("deprecation")
+		Preference clearCachePreference = findPreference(Constants.Preference.CLEAR_CACHE_KEY);
+		long cacheSizeUsed = MusicProviderUtils.getCachedSongSize(context);
+		String fuzzySpaceUsed = StorageUtils.getFuzzySize(cacheSizeUsed);
+		Log.i(TAG, String.format("Cache stats: songs %d used %s",
+				MusicProviderUtils.getCachedSongCount(context), fuzzySpaceUsed));
+		clearCachePreference.setSummary(String.format("Space used: %s", fuzzySpaceUsed));
+		clearCachePreference.setOnPreferenceClickListener(this);
+	}
+	
+	@Override
+	public boolean onPreferenceClick(Preference preference) {
+		String key = preference.getKey();
+		if (Constants.Preference.CLEAR_CACHE_KEY.equals(key)) {
+			if (mClearCacheTask == null) {
+				mClearCacheTask = new ClearCacheTask();
+				mClearCacheTask.execute();
+			}
+		}
+		return false;
+	}
+
+	public class ClearCacheTask extends AsyncTask<Integer, Void, Integer> {
+		private Context mContext = getApplicationContext();
+		
+		@Override
+		protected void onPreExecute() {
+			Toast.makeText(mContext, "Clearing cache...", Toast.LENGTH_SHORT).show();
+		}
+
+		@Override
+		protected Integer doInBackground(Integer... params) {
+			ContentResolver resolver = mContext.getContentResolver();
+			String[] projection = new String[] { Songs.SONG_ID, Songs.SONG_PATH };
+			String selection = Songs.STARRED + "!=1";
+			
+			Cursor cursor = null;
+			Integer deletedSongs = 0;
+			try {
+				cursor = resolver.query(Songs.CACHED_SONGS_URI, projection, selection, null, null);
+				if (cursor != null && cursor.moveToFirst()) {
+					int pathColumnIndex = cursor.getColumnIndex(Songs.SONG_PATH);
+					int songIdColumnIndex = cursor.getColumnIndex(Songs.SONG_ID);
+					do {
+						if (deleteSong(resolver, cursor, pathColumnIndex, songIdColumnIndex)) {
+							deletedSongs++;
+						}
+					} while (cursor.moveToNext());
+				}
+			} finally {
+				if (cursor != null) cursor.close();
+			}
+			return deletedSongs;
+		}
+		
+		private boolean deleteSong(ContentResolver resolver, Cursor cursor,
+				int pathColumnIndex, int songIdColumnIndex) {
+			String path = cursor.getString(pathColumnIndex);
+			String songId = cursor.getString(songIdColumnIndex);
+			File songFile = new File(path);
+			if (songFile.exists()) {
+				Uri songUri = Songs.buildSongUri(songId);
+				ContentValues values = new ContentValues();
+				values.putNull(Songs.SONG_PATH);
+				boolean entryUpdated = resolver.update(songUri, values, null, null) == 1;
+				return songFile.delete() && entryUpdated; 
+			}
+			return false;
+		}
+		
+		@Override
+		protected void onPostExecute(Integer result) {
+			Toast.makeText(mContext, String.format("Deleted %d songs.", result),
+					Toast.LENGTH_SHORT).show();
+			mClearCacheTask = null;
+			
+			if (!isFinishing()) {
+				setupClearCachePreference(PreferencesActivity.this);
+			}
+		}
+
+		@Override
+		protected void onCancelled() {
+			Toast.makeText(mContext, "Canceled.", Toast.LENGTH_SHORT).show();
+			mClearCacheTask = null;
+		}
+	}
+}
 
=== removed file 'main/src/com/ubuntuone/android/music/ui/SettingsActivity.java'
--- main/src/com/ubuntuone/android/music/ui/SettingsActivity.java	2012-12-14 04:29:46 +0000
+++ main/src/com/ubuntuone/android/music/ui/SettingsActivity.java	1970-01-01 00:00:00 +0000
@@ -1,29 +0,0 @@
-/*
- * Ubuntu One Music - stream music from Ubuntu One cloud storage.
- * 
- * Copyright 2012 Canonical Ltd.
- * 
- * This file is part of Ubuntu One Music app.
- * 
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as
- * published by the Free Software Foundation, either version 3 of the
- * License, or (at your option) any later version.
- * 
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Affero General Public License for more details.
- * 
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see http://www.gnu.org/licenses 
- */
-
-package com.ubuntuone.android.music.ui;
-
-import com.actionbarsherlock.app.SherlockPreferenceActivity;
-
-public class SettingsActivity extends SherlockPreferenceActivity
-{
-
-}
 
=== modified file 'main/src/com/ubuntuone/android/music/util/AccountUtils.java'
--- main/src/com/ubuntuone/android/music/util/AccountUtils.java	2013-01-23 02:36:20 +0000
+++ main/src/com/ubuntuone/android/music/util/AccountUtils.java	2013-01-25 16:20:29 +0000
@@ -92,11 +92,8 @@
 		if (accounts.length > 0) {
 			return U1_ACCOUNT_TYPE;
 		}
-		accounts = accountManager.getAccountsByType(OLD_U1_ACCOUNT_TYPE);
-		if (accounts.length > 0) {
-			return U1_ACCOUNT_TYPE;
-		}
-		return null;
+		// Otherwise, always return the old account type, regardless if the account exists.
+		return OLD_U1_ACCOUNT_TYPE;
 	}
 
     public static String getChosenAccountName(final Context context) {
 
=== added file 'main/src/com/ubuntuone/android/music/util/SeekBarPreference.java'
--- main/src/com/ubuntuone/android/music/util/SeekBarPreference.java	1970-01-01 00:00:00 +0000
+++ main/src/com/ubuntuone/android/music/util/SeekBarPreference.java	2013-01-25 16:20:29 +0000
@@ -0,0 +1,195 @@
+package com.ubuntuone.android.music.util;
+
+import static com.ubuntuone.android.music.util.StorageUtils.MiB;
+import android.content.Context;
+import android.content.res.TypedArray;
+import android.preference.Preference;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.ViewParent;
+import android.widget.RelativeLayout;
+import android.widget.SeekBar;
+import android.widget.SeekBar.OnSeekBarChangeListener;
+import android.widget.TextView;
+
+import com.ubuntuone.android.music.R;
+
+public class SeekBarPreference extends Preference implements
+		OnSeekBarChangeListener {
+	private final String TAG = getClass().getName();
+
+	private static final String ANDROID_NS = "http://schemas.android.com/apk/res/android";
+	private static final String UBUNTUONE_NS = "http://schemas.one.ubuntu.com/apk/res/android";
+	private static final int DEFAULT_VALUE = 50;
+
+	private int mMaxValue = 100;
+	private int mMinValue = 0;
+	private int mInterval = 1;
+	private int mCurrentValue;
+	private SeekBar mSeekBar;
+
+	private TextView mStatusText;
+
+	public void setMinValue(int min) {
+		mMinValue = min;
+		mSeekBar.setMax(mMaxValue - mMinValue);
+	}
+
+	public void setMaxValue(int max) {
+		mMaxValue = max;
+		mSeekBar.setMax(mMaxValue - mMinValue);
+	}
+
+	public SeekBarPreference(Context context, AttributeSet attrs) {
+		super(context, attrs);
+		initPreference(context, attrs);
+	}
+
+	public SeekBarPreference(Context context, AttributeSet attrs, int defStyle) {
+		super(context, attrs, defStyle);
+		initPreference(context, attrs);
+	}
+
+	private void initPreference(Context context, AttributeSet attrs) {
+		setValuesFromXml(attrs);
+		mSeekBar = new SeekBar(context, attrs);
+		mSeekBar.setMax(mMaxValue - mMinValue);
+		mSeekBar.setOnSeekBarChangeListener(this);
+	}
+
+	private void setValuesFromXml(AttributeSet attrs) {
+		mMaxValue = attrs.getAttributeIntValue(ANDROID_NS, "max", 100);
+		mMinValue = attrs.getAttributeIntValue(UBUNTUONE_NS, "min", 0);
+
+		try {
+			String newInterval = attrs.getAttributeValue(UBUNTUONE_NS, "interval");
+			if (newInterval != null) {
+				mInterval = Integer.parseInt(newInterval);
+			}
+		} catch (Exception e) {
+			Log.e(TAG, "Invalid interval value", e);
+		}
+
+	}
+
+	@SuppressWarnings("unused")
+	private String getAttributeStringValue(AttributeSet attrs,
+			String namespace, String name, String defaultValue) {
+		String value = attrs.getAttributeValue(namespace, name);
+		if (value == null) {
+			value = defaultValue;
+		}
+		return value;
+	}
+
+	@Override
+	protected View onCreateView(ViewGroup parent) {
+		RelativeLayout layout = null;
+		try {
+			LayoutInflater mInflater = (LayoutInflater) getContext()
+					.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
+
+			layout = (RelativeLayout) mInflater.inflate(
+					R.layout.seek_bar_preference, parent, false);
+		} catch (Exception e) {
+			Log.e(TAG, "Error creating seek bar preference", e);
+		}
+		return layout;
+	}
+
+	@Override
+	public void onBindView(View view) {
+		super.onBindView(view);
+		try {
+			ViewParent oldContainer = mSeekBar.getParent();
+			ViewGroup newContainer = (ViewGroup) view
+					.findViewById(R.id.seekBarPrefBarContainer);
+
+			if (oldContainer != newContainer) {
+				if (oldContainer != null) {
+					((ViewGroup) oldContainer).removeView(mSeekBar);
+				}
+				newContainer.removeAllViews();
+				newContainer.addView(mSeekBar,
+						ViewGroup.LayoutParams.MATCH_PARENT,
+						ViewGroup.LayoutParams.WRAP_CONTENT);
+			}
+		} catch (Exception ex) {
+			Log.e(TAG, "Error binding view: " + ex.toString());
+		}
+		updateView(view);
+	}
+
+	/**
+	 * Update a SeekBarPreference view with our current state
+	 * 
+	 * @param view
+	 */
+	protected void updateView(View view) {
+
+		try {
+			RelativeLayout layout = (RelativeLayout) view;
+			mStatusText = (TextView) layout.findViewById(R.id.seekBarPrefValue);
+			mStatusText.setMinimumWidth(30);
+			mSeekBar.setProgress(mCurrentValue - mMinValue);
+
+			mStatusText.setText(StorageUtils.getFuzzySize(mCurrentValue * MiB));
+		} catch (Exception e) {
+			Log.e(TAG, "Error updating seek bar preference", e);
+		}
+
+	}
+
+	@Override
+	public void onProgressChanged(SeekBar seekBar, int progress,
+			boolean fromUser) {
+		int newValue = progress + mMinValue;
+
+		if (newValue > mMaxValue)
+			newValue = mMaxValue;
+		else if (newValue < mMinValue)
+			newValue = mMinValue;
+		else if (mInterval != 1 && newValue % mInterval != 0)
+			newValue = Math.round(((float) newValue) / mInterval) * mInterval;
+
+		mCurrentValue = newValue;
+		if (mStatusText != null) {
+			mStatusText.setText(StorageUtils.getFuzzySize(newValue * MiB));
+		}
+		persistInt(newValue);
+	}
+
+	@Override
+	public void onStartTrackingTouch(SeekBar seekBar) {
+	}
+
+	@Override
+	public void onStopTrackingTouch(SeekBar seekBar) {
+		notifyChanged();
+	}
+
+	@Override
+	protected Object onGetDefaultValue(TypedArray typedArray, int index) {
+		int defaultValue = typedArray.getInt(index, DEFAULT_VALUE);
+		return defaultValue;
+	}
+
+	@Override
+	protected void onSetInitialValue(boolean restoreValue, Object defaultValue) {
+		if (restoreValue) {
+			mCurrentValue = getPersistedInt(mCurrentValue);
+		} else {
+			int value = 0;
+			try {
+				value = (Integer) defaultValue;
+			} catch (Exception ex) {
+				Log.e(TAG, "Invalid default value: " + defaultValue.toString());
+			}
+			persistInt(value);
+			mCurrentValue = value;
+		}
+	}
+}
 
=== added file 'main/src/com/ubuntuone/android/music/util/StorageUtils.java'
--- main/src/com/ubuntuone/android/music/util/StorageUtils.java	1970-01-01 00:00:00 +0000
+++ main/src/com/ubuntuone/android/music/util/StorageUtils.java	2013-01-25 16:20:29 +0000
@@ -0,0 +1,216 @@
+/*
+ * Ubuntu One Music - stream music from Ubuntu One cloud storage.
+ * 
+ * Copyright 2013 Canonical Ltd.
+ * 
+ * This file is part of Ubuntu One Music app.
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see http://www.gnu.org/licenses 
+ */
+
+package com.ubuntuone.android.music.util;
+
+import static com.ubuntuone.android.music.util.LogUtils.makeLogTag;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Locale;
+
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.os.Build;
+import android.os.Environment;
+import android.os.StatFs;
+import android.preference.PreferenceManager;
+import android.util.Log;
+
+import com.ubuntuone.android.music.Constants;
+import com.ubuntuone.android.music.Constants.Preference;
+
+/** Utility functions to query and store information about the SDCard "external storage". */
+public final class StorageUtils {
+	private static final String TAG = makeLogTag(StorageUtils.class.getSimpleName());
+
+	public static final String MUSIC_DIR = "u1music";
+
+	public static final long MiB = 1024*1024;
+	public static final long MIN_CACHE_SIZE = 100 * MiB;
+
+	private StorageUtils() {}
+
+	public static void setupMusicDirectory(Context context) {
+		SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(context);
+		String storage = preferences.getString(Preference.CACHE_LOCATION_KEY, null);
+		if (storage == null) {
+			final String[] storagePaths = StorageUtils.getAvailableStoragePaths();
+			Log.i(TAG, "Available storage paths: " + Arrays.toString(storagePaths));
+			if (storagePaths != null) {
+				storage = storagePaths[0];
+			} else {
+				storage = getGenericCacheDirectory();
+			}
+			PreferenceManager.getDefaultSharedPreferences(context).edit()
+					.putString(Constants.Preference.CACHE_LOCATION_KEY, storage).commit();
+			
+		} else {
+			Log.w(TAG, "No storage paths matched on " + Build.MODEL);
+		}
+
+		long avail = getAvailableStorage(context, storage);
+		long total = getTotalStorage(context, storage);
+		Log.i(TAG, String.format("Storage stats: avail %s total %s",
+				getFuzzySize(avail), getFuzzySize(total)));
+	}
+
+	/**
+	 * Returns the directory used to store cached music collection located on the selected storage. 
+	 * <br />
+	 * Prerequisite: <b>setupMusicDirectory</b> must be called before calling this method,
+	 * to initialize the default value of cache location preference.
+	 * 
+	 * @param context
+	 * 
+	 * @return Absolute path of the music storage directory.
+	 */
+	public static String getMusicDirectory(Context context) {
+		SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(context);
+		String cacheStorage = preferences.getString(Preference.CACHE_LOCATION_KEY, null);
+		String cacheDirectory = preferences.getString(Preference.CACHE_DIR_KEY, MUSIC_DIR);
+		if (cacheStorage == null) {
+			throw new IllegalStateException("storage is null, have you called setupMusicDirectory?");
+		}
+		File storageDirectory = new File(cacheStorage);
+		File musicDirectory = new File(storageDirectory, cacheDirectory);
+		if (!musicDirectory.exists()) {
+			musicDirectory.mkdirs();
+		}
+		return musicDirectory.getAbsolutePath();
+	}
+
+	/**
+	 * @return Absolute path of the default, generic music storage directory.
+	 */
+	public static String getGenericCacheDirectory() {
+		final File storageDirectory = Environment.getExternalStorageDirectory();
+		final File genericCache = new File(storageDirectory,
+				"Android/data/com.ubuntuone.android.music/files/cache");
+		if (!genericCache.isDirectory()) {
+			Log.i(TAG, "Creating cache directory.");
+			genericCache.delete(); // Doesn't throw IOException
+			genericCache.mkdirs();
+		}
+		return genericCache.getAbsolutePath();
+	}
+	
+	public static String getExternalStoragePath() {
+		return Environment.getExternalStorageDirectory().getAbsolutePath();
+	}
+	
+	@SuppressLint("SdCardPath") // Yada yada lint. getExternalStorageDirectory() is NOT enough.
+	private static final String[] knownStoragePaths = new String[] {
+		"/storage/sdcard0",
+		"/mnt/sdcard",
+		"/mnt/sdcard2",
+		"/mnt/sdcard-ext", // Motorola
+		"/mnt/sdcard/external_sd", // Samsung
+		"/mnt/ext_card", // Samsung
+		"/sdcard/_ExternalSD"
+	};
+	
+	public static String[] getAvailableStoragePaths() {
+		ArrayList<String> pathList = new ArrayList<String>();
+		for (String path : knownStoragePaths) {
+			File storage = new File(path);
+			if (storage.exists() && storage.isDirectory()) {
+				pathList.add(storage.getAbsolutePath());
+			}
+		}
+		int size = pathList.size();
+		return pathList.toArray(new String[size]);
+	}
+	
+	public static int getSelectedStorageIndex(String storage,
+			String[] storagePaths) throws InvalidStorage {
+		for (int i = 0; i < storagePaths.length; i++) {
+			if (storage.equals(storagePaths[i]))
+				return i;
+		}
+		throw new InvalidStorage();
+	}
+	
+	public static long getAvailableStorage(Context context, String storage) {
+		StatFs stat = new StatFs(getMusicDirectory(context));
+		long blocksAvailable = stat.getAvailableBlocks();
+		long blockSizeBytes = stat.getBlockSize();
+		return blocksAvailable * blockSizeBytes;
+	}
+	
+	/**
+	 * total space - free space - used cache size
+	 * 
+	 * @param context
+	 * @param storage
+	 * @return
+	 */
+	public static long getAvailableCacheStorage(Context context, String storage, long cacheSize) {
+		StatFs stat = new StatFs(getMusicDirectory(context));
+		long blocksAvailable = stat.getAvailableBlocks();
+		long blockSizeBytes = stat.getBlockSize();
+		long total = getTotalStorage(context, storage);
+		
+		long avail = blocksAvailable * blockSizeBytes;
+		return total - avail - cacheSize;
+	}
+	
+	public static long getTotalStorage(Context context, String storage) {
+		StatFs stat = new StatFs(getMusicDirectory(context));
+		long blocksCount = stat.getBlockCount();
+		long blockSizeBytes = stat.getBlockSize();
+		return blocksCount * blockSizeBytes;
+	}
+
+	public static String getFuzzySize(long size) {
+		String units = "B";
+		String formatString = "%.0f %s";
+		double s = size;
+		if (s > 1024.0) {
+			s /= 1024.0;
+			units = "KiB";
+		}
+		if (s > 1024.0) {
+			s /= 1024.0;
+			units = "MiB";
+			formatString = "%.02f %s";
+		}
+		if (s > 1024.0) {
+			s /= 1024.0;
+			units = "GiB";
+		}
+		return String.format(Locale.US, formatString, s, units);
+	}
+
+	public static class InvalidStorage extends Exception {
+		private static final long serialVersionUID = -3042684172473773638L;
+		public InvalidStorage() { super(); }
+		public InvalidStorage(String msg) { super(msg); }
+	}
+
+	public static class NoTertiaryStorage extends Exception {
+		private static final long serialVersionUID = -5605241960717201218L;
+		public NoTertiaryStorage() { super(); }
+		public NoTertiaryStorage(String msg) { super(msg); }
+	}
+}