Merge lp:~karni/ubuntuone-music-java-library/content-streaming into lp:ubuntuone-music-java-library

[Michał Karnicki]

This branch adds getSongStream and downloadSong methods, as well as handling non-200 http responses.

=== modified file 'src/main/com/ubuntuone/api/music/U1MusicAPI.java'
--- src/main/com/ubuntuone/api/music/U1MusicAPI.java	2012-06-19 01:09:20 +0000
+++ src/main/com/ubuntuone/api/music/U1MusicAPI.java	2012-06-19 01:09:20 +0000
@@ -33,13 +33,16 @@
 
 import javax.net.ssl.SSLException;
 
+import org.apache.http.Header;
 import org.apache.http.HttpEntity;
+import org.apache.http.HttpHeaders;
 import org.apache.http.HttpResponse;
 import org.apache.http.HttpStatus;
 import org.apache.http.client.HttpClient;
 import org.apache.http.client.methods.HttpDelete;
 import org.apache.http.client.methods.HttpGet;
 import org.apache.http.client.methods.HttpPost;
+import org.apache.http.util.EntityUtils;
 import org.codehaus.jackson.JsonParseException;
 
 import com.ubuntu.sso.authorizer.Authorizer;
@@ -47,6 +50,7 @@
 import com.ubuntuone.api.music.client.BaseClient;
 import com.ubuntuone.api.music.client.Failure;
 import com.ubuntuone.api.music.client.ResourceClient;
+import com.ubuntuone.api.music.client.StreamingClient;
 import com.ubuntuone.api.music.json.U1AlbumJson;
 import com.ubuntuone.api.music.json.U1ArtistJson;
 import com.ubuntuone.api.music.json.U1PlaylistJson;
@@ -55,12 +59,19 @@
 import com.ubuntuone.api.music.model.U1Album;
 import com.ubuntuone.api.music.model.U1Artist;
 import com.ubuntuone.api.music.model.U1Song;
+import com.ubuntuone.api.music.request.U1DownloadListener;
+import com.ubuntuone.api.music.util.CancelTrigger;
+import com.ubuntuone.api.music.util.CancelTrigger.RequestCanceledException;
+import com.ubuntuone.api.music.util.OnProgressListener;
+import com.ubuntuone.api.music.util.OnProgressListener.ProgressInputStream;
+import com.ubuntuone.api.music.util.RequestListener;
 import com.ubuntuone.api.music.util.RequestListener.U1AlbumRequestListener;
 import com.ubuntuone.api.music.util.RequestListener.U1ArtRequestListener;
 import com.ubuntuone.api.music.util.RequestListener.U1ArtistRequestListener;
 import com.ubuntuone.api.music.util.RequestListener.U1PlaylistRequestListener;
 import com.ubuntuone.api.music.util.RequestListener.U1PlaylistSongRequestListener;
 import com.ubuntuone.api.music.util.RequestListener.U1SongRequestListener;
+import com.ubuntuone.api.music.util.RequestListener.U1StreamRequestListener;
 import com.ubuntuone.api.music.util.RequestListener.U1VoidRequestListener;
 import com.ubuntuone.api.music.util.ResponseHeader;
 import com.ubuntuone.api.music.util.StreamUtils;
@@ -78,27 +89,35 @@
 	public static final String PLAYLISTS = "playlists";
 
 	protected static final String RESOURCE_HOST = "one.ubuntu.com";
+	// TODO karni: Set this to proper streaming host when streaming handler is ready.
+	protected static final String STREAMING_HOST = "streaming.one.ubuntu.com";
 	
 	private final ResourceClient resourceClient;
+	private final StreamingClient streamingClient;
 	
 	private static Logger logger = Logger.getLogger(U1MusicAPI.LOGGER_NAME);
 
-	public U1MusicAPI(String scheme, String resourceHost,
+	public U1MusicAPI(String userAgent, String scheme,
+			String resourceHost, String streamingHost,
 			HttpClient httpClient, Authorizer authorizer) {
 		logger = Logger.getLogger(U1MusicAPI.class.getCanonicalName());
 		logger.setLevel(Level.INFO);
 		
-		this.resourceClient = new ResourceClient(
+		this.resourceClient = new ResourceClient(userAgent,
 				scheme, resourceHost, httpClient, authorizer);
-	}
-	
-	public U1MusicAPI(String resourceHost, HttpClient httpClient,
-			Authorizer authorizer) {
-		this(BaseClient.HTTPS, resourceHost, httpClient, authorizer);
-	}
-	
-	public U1MusicAPI(HttpClient httpClient, Authorizer authorizer) {
-		this(BaseClient.HTTPS, RESOURCE_HOST, httpClient, authorizer);
+		this.streamingClient = new StreamingClient(userAgent,
+				scheme, streamingHost, httpClient, authorizer);
+	}
+	
+	public U1MusicAPI(String userAgent, String resourceHost,
+			String steramingHost, HttpClient httpClient, Authorizer authorizer) {
+		this(userAgent, BaseClient.HTTPS, resourceHost, steramingHost,
+				httpClient, authorizer);
+	}
+	
+	public U1MusicAPI(String userAgent, HttpClient httpClient, Authorizer authorizer) {
+		this(userAgent, BaseClient.HTTPS, RESOURCE_HOST, STREAMING_HOST,
+				httpClient, authorizer);
 	}
 
 	public void getArtists(U1ArtistRequestListener callback) {
@@ -111,16 +130,15 @@
 			if (statusCode == HttpStatus.SC_OK) {
 				U1ArtistJson.fromJson(getContentInputStream(response), callback);
 			} else {
-				// TODO handleNon200HttpResponse(response, "Could not get artists.", callback);
+				handleHttpResponse(response, "Could not get artists.", callback);
 			}
 		} catch (JsonParseException jpe) {
 			// Received corrupt JSON. At this stage, response != null
-			final String oopsId = getHeaderValue(ResponseHeader.X_OOPS_ID, response); 
 			final String bzrRev = getHeaderValue(ResponseHeader.X_BZR_REVISION_NUMBER, response);
 			final String date = getHeaderValue(ResponseHeader.DATE, response);
 			
 			callback.onFailure(new Failure("Could not get artists. Corrupt JSON.",
-					jpe, 0, oopsId, bzrRev, date));
+					jpe, 0, null, bzrRev, date));
 		}  catch (OutOfMemoryError e) {
 			callback.onFailure(new Failure("Out of memory!", e));
 			throw e; // We're not expected to recover from this.
@@ -150,16 +168,15 @@
 			if (statusCode == HttpStatus.SC_OK) {
 				U1AlbumJson.fromJson(getContentInputStream(response), callback);
 			} else {
-				// TODO handleNon200HttpResponse(response, "Could not get albums.", callback);
+				handleHttpResponse(response, "Could not get albums.", callback);
 			}
 		} catch (JsonParseException jpe) {
 			// Received corrupt JSON. At this stage, response != null
-			final String oopsId = getHeaderValue(ResponseHeader.X_OOPS_ID, response); 
 			final String bzrRev = getHeaderValue(ResponseHeader.X_BZR_REVISION_NUMBER, response);
 			final String date = getHeaderValue(ResponseHeader.DATE, response);
 			
 			callback.onFailure(new Failure("Could not get albums. Corrupt JSON.",
-					jpe, 0, oopsId, bzrRev, date));
+					jpe, 0, null, bzrRev, date));
 		}  catch (OutOfMemoryError e) {
 			callback.onFailure(new Failure("Out of memory!", e));
 			throw e; // We're not expected to recover from this.
@@ -189,16 +206,15 @@
 			if (statusCode == HttpStatus.SC_OK) {
 				U1SongJson.fromJson(getContentInputStream(response), callback);
 			} else {
-				// TODO handleNon200HttpResponse(response, "Could not get songs.", callback);
+				handleHttpResponse(response, "Could not get songs.", callback);
 			}
 		} catch (JsonParseException jpe) {
 			// Received corrupt JSON. At this stage, response != null
-			final String oopsId = getHeaderValue(ResponseHeader.X_OOPS_ID, response); 
 			final String bzrRev = getHeaderValue(ResponseHeader.X_BZR_REVISION_NUMBER, response);
 			final String date = getHeaderValue(ResponseHeader.DATE, response);
 			
 			callback.onFailure(new Failure("Could not get songs. Corrupt JSON.",
-					jpe, 0, oopsId, bzrRev, date));
+					jpe, 0, null, bzrRev, date));
 		}  catch (OutOfMemoryError e) {
 			callback.onFailure(new Failure("Out of memory!", e));
 			throw e; // We're not expected to recover from this.
@@ -228,16 +244,15 @@
 			if (statusCode == HttpStatus.SC_OK) {
 				U1PlaylistJson.fromJson(getContentInputStream(response), callback);
 			} else {
-				// TODO handleNon200HttpResponse(response, "Could not get playlists.", callback);
+				handleHttpResponse(response, "Could not get playlists.", callback);
 			}
 		} catch (JsonParseException jpe) {
 			// Received corrupt JSON. At this stage, response != null
-			final String oopsId = getHeaderValue(ResponseHeader.X_OOPS_ID, response); 
 			final String bzrRev = getHeaderValue(ResponseHeader.X_BZR_REVISION_NUMBER, response);
 			final String date = getHeaderValue(ResponseHeader.DATE, response);
 			
 			callback.onFailure(new Failure("Could not get playlists. Corrupt JSON.",
-					jpe, 0, oopsId, bzrRev, date));
+					jpe, 0, null, bzrRev, date));
 		}  catch (OutOfMemoryError e) {
 			callback.onFailure(new Failure("Out of memory!", e));
 			throw e; // We're not expected to recover from this.
@@ -267,16 +282,15 @@
 			if (statusCode == HttpStatus.SC_OK) {
 				U1PlaylistSongJson.fromJson(getContentInputStream(response), callback);
 			} else {
-				// TODO handleNon200HttpResponse(response, "Could not get playlist.", callback);
+				handleHttpResponse(response, "Could not get playlist.", callback);
 			}
 		} catch (JsonParseException jpe) {
 			// Received corrupt JSON. At this stage, response != null
-			final String oopsId = getHeaderValue(ResponseHeader.X_OOPS_ID, response); 
 			final String bzrRev = getHeaderValue(ResponseHeader.X_BZR_REVISION_NUMBER, response);
 			final String date = getHeaderValue(ResponseHeader.DATE, response);
 			
 			callback.onFailure(new Failure("Could not get playlist. Corrupt JSON.",
-					jpe, 0, oopsId, bzrRev, date));
+					jpe, 0, null, bzrRev, date));
 		}  catch (OutOfMemoryError e) {
 			callback.onFailure(new Failure("Out of memory!", e));
 			throw e; // We're not expected to recover from this.
@@ -307,16 +321,15 @@
 			if (statusCode == HttpStatus.SC_OK) {
 				U1PlaylistSongJson.fromJson(getContentInputStream(response), callback);
 			} else {
-				// TODO handleNon200HttpResponse(response, "Could not get playlist.", callback);
+				handleHttpResponse(response, "Could not create playlist.", callback);
 			}
 		} catch (JsonParseException jpe) {
 			// Received corrupt JSON. At this stage, response != null
-			final String oopsId = getHeaderValue(ResponseHeader.X_OOPS_ID, response); 
 			final String bzrRev = getHeaderValue(ResponseHeader.X_BZR_REVISION_NUMBER, response);
 			final String date = getHeaderValue(ResponseHeader.DATE, response);
 			
 			callback.onFailure(new Failure("Could not create playlist. Corrupt JSON.",
-					jpe, 0, oopsId, bzrRev, date));
+					jpe, 0, null, bzrRev, date));
 		}  catch (OutOfMemoryError e) {
 			callback.onFailure(new Failure("Out of memory!", e));
 			throw e; // We're not expected to recover from this.
@@ -346,7 +359,7 @@
 			if (statusCode == HttpStatus.SC_OK) {
 				callback.onSuccess(null);
 			} else {
-				// TODO handleNon200HttpResponse(response, "Could not get playlist.", callback);
+				handleHttpResponse(response, "Could not delete playlist.", callback);
 			}
 		} catch (SSLException sslException) {
 			callback.onFailure(new Failure("SSL connection problem. This may be intermittent issue, " +
@@ -361,7 +374,7 @@
 			callback.onFailure(new Failure("Could not delete playlist (signing exception).", signingException));
 		} finally {
 			callback.onFinish();
-		}		
+		}
 	}
 	
 	private void getArt(String path, String filePath, U1ArtRequestListener callback) {
@@ -382,7 +395,7 @@
 				out.close();
 				callback.onSuccess(artFile);
 			} else {
-				// TODO handleNon200HttpResponse(response, "Could not get playlist.", callback);
+				handleHttpResponse(response, "Could not get art.", callback);
 			}
 		} catch (SSLException sslException) {
 			callback.onFailure(new Failure("SSL connection problem. This may be intermittent issue, " +
@@ -400,20 +413,186 @@
 		}
 	}
 	
-	public void getArt(U1Artist artist, String filePath, U1ArtRequestListener callback) {
+	public void getArt(U1Artist artist, String filePath,
+			U1ArtRequestListener callback) {
 		String path = resourceClient.getArtPath(ARTISTS, artist.getId());
 		getArt(path, filePath, callback);
 	}
 	
-	public void getArt(U1Album album, String filePath, U1ArtRequestListener callback) {
+	public void getArt(U1Album album, String filePath,
+			U1ArtRequestListener callback) {
 		String path = resourceClient.getArtPath(ALBUMS, album.getId());
 		getArt(path, filePath, callback);
 	}
 	
-	public void getArt(U1Song song, String filePath, U1ArtRequestListener callback) {
+	public void getArt(U1Song song, String filePath,
+			U1ArtRequestListener callback) {
 		String path = resourceClient.getArtPath(ALBUMS, song.getAlbumId());
 		getArt(path, filePath, callback);
 	}
+
+	public void getSongStream(U1Song song, long offset,
+			U1StreamRequestListener callback) {
+		callback.onStart();
+		String path = streamingClient.getPath(song.getId());
+		HttpResponse response = null;
+		try {
+			response = streamingClient.download(path, offset, null);
+			final int statusCode = getStatusCode(response);
+			if (statusCode == HttpStatus.SC_OK) {
+				callback.onSuccess(getContentInputStream(response));
+			} else {
+				handleHttpResponse(response, "Could not get song stream.", callback);
+			}
+		} catch (SSLException sslException) {
+			callback.onFailure(new Failure("SSL connection problem. This may be intermittent issue, " +
+					"please try again later.", sslException));
+		} catch (IOException ioException) {
+			// Failed to read the response.
+			callback.onFailure(new Failure("Could not get song stream (network error).", ioException));
+		} catch (URISyntaxException uriSyntaxException) {
+			// Failed due to invalid URL within the library code.
+			throw new IllegalStateException(uriSyntaxException);
+		} catch (AuthorizerException signingException) {
+			callback.onFailure(new Failure("Could not get song stream (signing exception).", signingException));
+		} catch (RequestCanceledException e) {
+			// Ignore.
+		} finally {
+			callback.onFinish();
+		}
+	}
+	
+	// TODO karni: add tests
+	public void downloadSong(U1Song song, String localPath,
+			U1DownloadListener callback, CancelTrigger cancelTrigger) {
+		callback.onStart();
+		final String contentPath = streamingClient.getPath(song.getId());
+		HttpResponse response = null;
+		int statusCode = 0;
+		try {
+			final File file = new File(localPath);
+			file.getParentFile().mkdirs();
+			long offset = file.exists() ? file.length() : 0L;
+			
+			if (offset > 0) {
+				// Attempt to resume download.
+				response = streamingClient.download(
+						contentPath, offset, cancelTrigger);
+				statusCode = getStatusCode(response);
+				if (statusCode != HttpStatus.SC_PARTIAL_CONTENT) {
+					HttpEntity entity = response.getEntity();
+					if (entity != null) {
+						EntityUtils.consume(entity);
+					}
+					offset = 0;
+				}
+			}
+			
+			if (statusCode != HttpStatus.SC_PARTIAL_CONTENT) {
+				response = streamingClient.download(
+						contentPath, offset, cancelTrigger);
+				statusCode = getStatusCode(response);
+			}
+			
+			if (statusCode >= 200 && statusCode < 300) {
+				final boolean isResuming = offset > 0;
+				logger.info(String.format("%s download to %s",
+						isResuming ? "Resuming" : "Starting", file.getPath()));
+				
+				final Header contentLength = response.getFirstHeader(HttpHeaders.CONTENT_LENGTH);
+				final long size = Long.valueOf(contentLength.getValue());
+				final ProgressInputStream in = new ProgressInputStream(
+						getContentInputStream(response), offset, offset + size, (OnProgressListener) callback);
+				
+				final FileOutputStream stream = new FileOutputStream(file, isResuming);
+				in.writeTo(stream);
+				callback.onSuccess(true);
+			} else if (cancelTrigger != null && cancelTrigger.isCancelled()) {
+				// Do nothing, request has been cancelled.
+			} else {
+				handleHttpResponse(response, "Could not download song.", callback);
+			}
+		} catch (RequestCanceledException canceledException) {
+			callback.onCancel();
+		} catch (SSLException sslException) {
+			callback.onFailure(new Failure("SSL connection problem. This may be intermittent issue, " +
+					"please try again later.", sslException));
+		} catch (IOException ioException) {
+			// Failed to read the response.
+			callback.onFailure(new Failure("Could not download song (network error).", ioException));
+		} catch (URISyntaxException uriSyntaxException) {
+			// Failed due to invalid URL within the library code.
+			throw new IllegalStateException(uriSyntaxException);
+		} catch (AuthorizerException signingException) {
+			callback.onFailure(new Failure("Could not download song (signing exception).", signingException));
+		} finally {
+			callback.onFinish();
+		}
+	}
+	
+	private void handleHttpResponse(HttpResponse response,
+			String message, RequestListener<?> callback) {
+		final int statusCode = getStatusCode(response);
+		
+		switch (statusCode) {
+		case HttpStatus.SC_TEMPORARY_REDIRECT:
+			callback.onFailure(new Failure(
+					String.format("%s Redirected.", message), statusCode));
+			break;
+		case HttpStatus.SC_UNAUTHORIZED:
+			callback.onFailure(new Failure(
+					String.format("%s Unauthorized. Please log in again.",
+							message), statusCode));
+			break;
+		case HttpStatus.SC_FORBIDDEN:
+			callback.onFailure(new Failure(
+					String.format("%s Forbidden.", message), statusCode));
+			break;
+		case HttpStatus.SC_BAD_REQUEST:
+			callback.onFailure(new Failure(
+					String.format("%s Bad request.", message), statusCode));
+			break;
+		case HttpStatus.SC_NOT_FOUND:
+			callback.onFailure(new Failure(
+					String.format("%s Resource not found.", message), statusCode));
+			break;
+		case HttpStatus.SC_REQUEST_TIMEOUT:
+			callback.onFailure(new Failure(
+					String.format("%s Request timeout.", message), statusCode));
+			break;
+		case HttpStatus.SC_INTERNAL_SERVER_ERROR:
+			final String oopsId = getHeaderValue(
+					ResponseHeader.X_OOPS_ID, response); 
+			final String bzrRev = getHeaderValue(
+					ResponseHeader.X_BZR_REVISION_NUMBER, response);
+			final String date = getHeaderValue(
+					ResponseHeader.DATE, response);
+			
+			callback.onFailure(new Failure(
+					String.format("%s Server problem.", message), statusCode,
+					oopsId, bzrRev, date));
+			
+			break;
+		case HttpStatus.SC_SERVICE_UNAVAILABLE:
+			callback.onFailure(new Failure(
+					String.format("%s Service temporarily unavailable.",
+							message), statusCode));
+			break;
+		default:
+			callback.onFailure(new Failure(
+					String.format("%s Response failure (%d).",
+							message, statusCode), statusCode));
+			break;
+		}
+		HttpEntity entity = response.getEntity();
+		if (entity != null) {
+			try {
+				EntityUtils.consume(entity);
+			} catch (IOException e) {
+				// Ignore.
+			}
+		}
+	}
 	
 	private static final int getStatusCode(HttpResponse response) {
 		return response != null ? response.getStatusLine().getStatusCode() : null;
@@ -428,16 +607,4 @@
 			throws IllegalStateException, IOException {
 		return response != null ? response.getEntity().getContent() : null;
 	}
-	
-	@SuppressWarnings("unused")
-	private static final void consumeContent(HttpEntity entity) {
-		if (entity != null) {
-			try {
-				final InputStream in = entity.getContent();
-				if (in != null) in.close();
-			} catch (Exception e) {
-				// Ignore.
-			}
-		}
-	}
 }

=== modified file 'src/main/com/ubuntuone/api/music/client/ResourceClient.java'
--- src/main/com/ubuntuone/api/music/client/ResourceClient.java	2012-06-19 01:09:20 +0000
+++ src/main/com/ubuntuone/api/music/client/ResourceClient.java	2012-06-19 01:09:20 +0000
@@ -43,9 +43,16 @@
 
 public class ResourceClient extends BaseClient
 {
-	public ResourceClient(String scheme, String hostname,
+	private final String CONNECTION = "CLOSE";
+	private final String ACCEPT = "application/json";
+	private final String UTF8 = "UTF-8";
+	
+	private String userAgent;
+	
+	public ResourceClient(String userAgent, String scheme, String hostname,
 			HttpClient httpClient, Authorizer authorizer) {
 		super(scheme, hostname, httpClient, authorizer);
+		this.userAgent = userAgent;
 	}
 	
 	public String getPath(String type) {
@@ -78,22 +85,21 @@
 		final HttpClient httpClient = getHttpClient();
 		String query = null;
 		if (params != null) {
-			query = URLEncodedUtils.format(params, "UTF-8");
+			query = URLEncodedUtils.format(params, UTF8);
 		}
 		final URI uri = new URI(getHost().getSchemeName(), getHost().getHostName(), path, query, null);
 		
 		// SignPost OAuth only knows how to sign HttpUriRequest.
 		final HttpUriRequest request =
 				HttpUriRequestFactory.buildUriRequest(method, uri.toString());
-		request.addHeader(HttpHeaders.USER_AGENT, "u1-music-java-library");
-		request.addHeader(HttpHeaders.CONNECTION, "close");
-		request.addHeader(HttpHeaders.ACCEPT, "application/json");
+		request.addHeader(HttpHeaders.USER_AGENT, userAgent);
+		request.addHeader(HttpHeaders.CONNECTION, CONNECTION);
+		request.addHeader(HttpHeaders.ACCEPT, ACCEPT);
 		if (data != null && HttpPut.METHOD_NAME.equals(method)) {
-			((HttpPut) request).setEntity(new StringEntity(data, "UTF-8"));
+			((HttpPut) request).setEntity(new StringEntity(data, UTF8));
 		}
 		
 		sign(request);
-		// System.out.println("Resource client: " + request.getRequestLine().toString());
 		return httpClient.execute(getHost(), request);
 	}
 

=== added file 'src/main/com/ubuntuone/api/music/client/StreamingClient.java'
--- src/main/com/ubuntuone/api/music/client/StreamingClient.java	1970-01-01 00:00:00 +0000
+++ src/main/com/ubuntuone/api/music/client/StreamingClient.java	2012-06-19 01:09:20 +0000
@@ -0,0 +1,79 @@
+/*
+ * Ubuntu One Music Java library - communicate with Ubuntu One music API
+ * 
+ * Copyright 2012 Canonical Ltd.
+ *   
+ * This file is part of Ubuntu One Files Java library.
+ *  
+ * 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.api.music.client;
+
+import java.io.IOException;
+import java.net.URI;
+import java.net.URISyntaxException;
+
+import javax.net.ssl.SSLException;
+
+import org.apache.http.HttpHeaders;
+import org.apache.http.HttpResponse;
+import org.apache.http.client.HttpClient;
+import org.apache.http.client.methods.HttpGet;
+
+import com.ubuntu.sso.authorizer.Authorizer;
+import com.ubuntu.sso.authorizer.AuthorizerException;
+import com.ubuntuone.api.music.util.CancelTrigger;
+import com.ubuntuone.api.music.util.CancelTrigger.RequestCanceledException;
+
+public class StreamingClient extends BaseClient
+{
+	private final String CONNECTION = "CLOSE";
+	private final String RANGE_FMT = "bytes=%d-";
+	
+	private String userAgent;
+	
+	public StreamingClient(String userAgent, String scheme, String hostname,
+			HttpClient httpClient, Authorizer authorizer) {
+		super(scheme, hostname, httpClient, authorizer);
+		this.userAgent = userAgent;
+	}
+	
+	@Override
+	public String getPath(String songId) {
+		// TODO karni: Set this to proper streaming path when streaming handler is ready.
+		return String.format("/stream/%s/", songId);
+	}
+
+	public HttpResponse download(String path, long offset,
+			CancelTrigger cancelTrigger) throws IOException, SSLException,
+			AuthorizerException, URISyntaxException, RequestCanceledException {
+		final HttpClient httpClient = getHttpClient();
+		
+		final URI uri = new URI(getHost().getSchemeName(), getHost().getHostName(), path, null);
+		
+		final HttpGet httpGet = new HttpGet(uri.toString());
+		if (cancelTrigger != null) {
+			cancelTrigger.setRequest(httpGet);
+		}
+		httpGet.addHeader(HttpHeaders.USER_AGENT, userAgent);
+		httpGet.addHeader(HttpHeaders.CONNECTION, CONNECTION);
+		if (offset > 0) {
+			httpGet.addHeader(HttpHeaders.RANGE, String.format(RANGE_FMT, offset));
+		}
+		
+		sign(httpGet);
+		return httpClient.execute(getHost(), httpGet);
+	}
+}

=== added file 'src/main/com/ubuntuone/api/music/request/U1DownloadListener.java'
--- src/main/com/ubuntuone/api/music/request/U1DownloadListener.java	1970-01-01 00:00:00 +0000
+++ src/main/com/ubuntuone/api/music/request/U1DownloadListener.java	2012-06-19 01:09:20 +0000
@@ -0,0 +1,58 @@
+/*
+ * Ubuntu One Music Java library - communicate with Ubuntu One music API
+ * 
+ * Copyright 2012 Canonical Ltd.
+ *   
+ * This file is part of Ubuntu One Files Java library.
+ *  
+ * 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.api.music.request;
+
+import com.ubuntuone.api.music.client.Failure;
+import com.ubuntuone.api.music.util.OnCancelListener;
+import com.ubuntuone.api.music.util.OnProgressListener;
+import com.ubuntuone.api.music.util.RequestListener;
+
+public abstract class U1DownloadListener implements RequestListener<Boolean>,
+		OnProgressListener, OnCancelListener
+{
+	@Override
+	public void onStart() {
+	}
+
+	@Override
+	public final void onSuccess(Boolean success) {
+		onSuccess();
+	}
+	
+	public abstract void onSuccess();
+
+	@Override
+	public void onFailure(Failure failure) {
+	}
+	
+	@Override
+	public void onProgress(long bytes, long total) {
+	}
+
+	@Override
+	public void onCancel() {
+	}
+	
+	@Override
+	public void onFinish() {
+	}
+}

=== added file 'src/main/com/ubuntuone/api/music/util/CancelTrigger.java'
--- src/main/com/ubuntuone/api/music/util/CancelTrigger.java	1970-01-01 00:00:00 +0000
+++ src/main/com/ubuntuone/api/music/util/CancelTrigger.java	2012-06-19 01:09:20 +0000
@@ -0,0 +1,66 @@
+/*
+ * Ubuntu One Files Java library - communicate with Ubuntu One storage API
+ * 
+ * Copyright (C) 2012 Canonical Ltd.
+ *   
+ * This file is part of Ubuntu One Files Java library.
+ *  
+ * 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.api.music.util;
+
+import org.apache.http.client.methods.HttpUriRequest;
+
+public class CancelTrigger
+{
+	private boolean isCanceled = false;
+	
+	private HttpUriRequest request;
+	
+	public CancelTrigger() {
+	}
+	
+	public CancelTrigger(HttpUriRequest request)
+			throws RequestCanceledException {
+		if (isCanceled) {
+			throw new RequestCanceledException();
+		}
+		this.request = request;
+	}
+	
+	public void setRequest(HttpUriRequest request)
+			throws RequestCanceledException {
+		if (isCanceled) {
+			throw new RequestCanceledException();
+		}
+		this.request = request;
+	}
+	
+	public void onCancel() {
+		isCanceled = true;
+		if (request != null) {
+			request.abort();
+		}
+	}
+	
+	public boolean isCancelled() {
+		return isCanceled;
+	}
+	
+	public static class RequestCanceledException extends Throwable
+	{
+		private static final long serialVersionUID = 4941090948169937930L;
+	}
+}

=== added file 'src/main/com/ubuntuone/api/music/util/OnCancelListener.java'
--- src/main/com/ubuntuone/api/music/util/OnCancelListener.java	1970-01-01 00:00:00 +0000
+++ src/main/com/ubuntuone/api/music/util/OnCancelListener.java	2012-06-19 01:09:20 +0000
@@ -0,0 +1,31 @@
+/*
+ * Ubuntu One Files Java library - communicate with Ubuntu One storage API
+ * 
+ * Copyright (C) 2012 Canonical Ltd.
+ *   
+ * This file is part of Ubuntu One Files Java library.
+ *  
+ * 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.api.music.util;
+
+
+public interface OnCancelListener
+{
+	/**
+	 * Called when the request has been cancelled (with a {@link CancelTrigger}.
+	 */
+	public void onCancel();
+}

=== added file 'src/main/com/ubuntuone/api/music/util/OnProgressListener.java'
--- src/main/com/ubuntuone/api/music/util/OnProgressListener.java	1970-01-01 00:00:00 +0000
+++ src/main/com/ubuntuone/api/music/util/OnProgressListener.java	2012-06-19 01:09:20 +0000
@@ -0,0 +1,165 @@
+/*
+ * Ubuntu One Files Java library - communicate with Ubuntu One storage API
+ * 
+ * Copyright (C) 2012 Canonical Ltd.
+ *   
+ * This file is part of Ubuntu One Files Java library.
+ *  
+ * 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.api.music.util;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+import org.apache.http.HttpEntity;
+import org.apache.http.entity.HttpEntityWrapper;
+
+public interface OnProgressListener
+{	
+	/**
+	 * If the request is a transfer (upload or download), implement this method
+	 * to get call backs with the transfer progress.
+	 * 
+	 * @param bytes
+	 *            The number of bytes transferred.
+	 * @param total
+	 *            The total number of bytes to transfer.
+	 */
+	public abstract void onProgress(long bytes, long total);
+	
+	// Decrease this value for more fine grained progress call backs.
+	static final long PROGRESS_INTERVAL = 400L;
+	
+	/**
+	 * An {@link HttpEntity} used for uploading content with feedback.
+	 */
+	public static class ProgressHttpEntity extends HttpEntityWrapper
+	{
+		private static final int CHUNK_SIZE = 1024 * 8;
+		
+		private HttpEntity entity;
+		
+		private OnProgressListener listener;
+		
+		public ProgressHttpEntity(HttpEntity entity, OnProgressListener listener) {
+			super(entity);
+			this.entity = entity;
+			this.listener = listener != null ? listener : new DummyListener();
+		}
+		
+		public void writeTo(OutputStream out) throws IllegalStateException, IOException {
+			final InputStream in = entity.getContent();
+			long lastCallback = 0, now = 0;
+			
+			byte buffer[] = new byte[CHUNK_SIZE];
+			long length = entity.getContentLength();
+			long total = 0L;
+			int bytes = 0;
+			
+			while ((bytes = in.read(buffer, 0, CHUNK_SIZE)) > 0) {
+				out.write(buffer, 0, bytes);
+				total += bytes;
+				now = System.currentTimeMillis();
+				if (now - lastCallback >= getProgressInterval()) {
+					listener.onProgress(total, length);
+					lastCallback = now;
+				}
+			}
+			if (total == length) {
+				listener.onProgress(total, length);
+			}
+			out.flush();
+			out.close();
+			
+			in.close();
+		}
+		
+		/**
+		 * Override for different update frequency interval.
+		 * 
+		 * @return
+		 */
+		public long getProgressInterval() {
+			return PROGRESS_INTERVAL;
+		}
+	}
+	
+	/**
+	 * An {@link InputStream} used for downloading content with feedback.
+	 */
+	public static class ProgressInputStream
+	{
+		private static final int CHUNK_SIZE = 1024 * 8;
+		
+		private InputStream stream;
+		// Bytes already saved (for partial content requests).
+		private long bytes;
+		
+		private long length;
+		
+		private OnProgressListener listener;
+		
+		public ProgressInputStream(InputStream stream, long bytes, long length,
+				OnProgressListener listener) {
+			this.stream = stream;
+			this.bytes = bytes;
+			this.length = length;
+			this.listener = listener != null ? listener : new DummyListener();
+		}
+		
+		public void writeTo(OutputStream out) throws IllegalStateException, IOException {
+			long lastCallback = 0, now = 0;
+			
+			byte buffer[] = new byte[CHUNK_SIZE];
+			long total = this.bytes;
+			int bytes = 0;
+			
+			while ((bytes = stream.read(buffer, 0, CHUNK_SIZE)) > 0) {
+				out.write(buffer, 0, bytes);
+				total += bytes;
+				now = System.currentTimeMillis();
+				if (now - lastCallback >= getProgressInterval()) {
+					listener.onProgress(total, length);
+					lastCallback = now;
+				}
+			}
+			if (total == length) {
+				listener.onProgress(total, length);
+			}
+			out.flush();
+			out.close();
+			
+			stream.close();
+		}
+		
+		/**
+		 * Override for different update frequency interval.
+		 * 
+		 * @return
+		 */
+		public long getProgressInterval() {
+			return PROGRESS_INTERVAL;
+		}
+	}
+	
+	public class DummyListener implements OnProgressListener {
+		@Override
+		public void onProgress(long bytes, long total) {
+			// Do nothing.
+		}
+	}
+}

=== modified file 'src/main/com/ubuntuone/api/music/util/RequestListener.java'
--- src/main/com/ubuntuone/api/music/util/RequestListener.java	2012-06-19 01:09:20 +0000
+++ src/main/com/ubuntuone/api/music/util/RequestListener.java	2012-06-19 01:09:20 +0000
@@ -22,6 +22,7 @@
 package com.ubuntuone.api.music.util;
 
 import java.io.File;
+import java.io.InputStream;
 
 import org.apache.http.HttpStatus;
 
@@ -76,4 +77,5 @@
 	public interface U1PlaylistSongRequestListener extends RequestListener<U1PlaylistSong> {};
 	public interface U1ArtRequestListener extends RequestListener<File> {};
 	public interface U1VoidRequestListener extends RequestListener<Void> {};
+	public interface U1StreamRequestListener extends RequestListener<InputStream> {};
 }
\ No newline at end of file

=== modified file 'src/test/com/ubuntuone/api/music/DeletePlaylistTest.java'
--- src/test/com/ubuntuone/api/music/DeletePlaylistTest.java	2012-06-19 01:09:20 +0000
+++ src/test/com/ubuntuone/api/music/DeletePlaylistTest.java	2012-06-19 01:09:20 +0000
@@ -69,7 +69,7 @@
 		httpResponse = Util.buildResponse(HttpStatus.SC_OK);
 				
 		httpClient = context.mock(HttpClient.class);
-		musicApi = new U1MusicAPI(httpClient, new DummyAuthorizer());
+		musicApi = new U1MusicAPI("ua/1.0", httpClient, new DummyAuthorizer());
 		
 		requestCallback = context.mock(U1VoidRequestListener.class);
 	}

=== modified file 'src/test/com/ubuntuone/api/music/GetAlbumsTest.java'
--- src/test/com/ubuntuone/api/music/GetAlbumsTest.java	2012-06-19 01:09:20 +0000
+++ src/test/com/ubuntuone/api/music/GetAlbumsTest.java	2012-06-19 01:09:20 +0000
@@ -72,7 +72,7 @@
 		httpResponse = Util.buildResponse(HttpStatus.SC_OK);
 				
 		httpClient = context.mock(HttpClient.class);
-		musicApi = new U1MusicAPI(httpClient, new DummyAuthorizer());
+		musicApi = new U1MusicAPI("ua/1.0", httpClient, new DummyAuthorizer());
 		
 		albumCallback = context.mock(U1AlbumRequestListener.class);
 	}

=== modified file 'src/test/com/ubuntuone/api/music/GetArtTest.java'
--- src/test/com/ubuntuone/api/music/GetArtTest.java	2012-06-19 01:09:20 +0000
+++ src/test/com/ubuntuone/api/music/GetArtTest.java	2012-06-19 01:09:20 +0000
@@ -79,7 +79,7 @@
 		httpResponse = Util.buildResponse(HttpStatus.SC_OK);
 				
 		httpClient = context.mock(HttpClient.class);
-		musicApi = new U1MusicAPI(httpClient, new DummyAuthorizer());
+		musicApi = new U1MusicAPI("ua/1.0", httpClient, new DummyAuthorizer());
 		
 		artCallback = context.mock(U1ArtRequestListener.class);
 	}

=== modified file 'src/test/com/ubuntuone/api/music/GetArtistsTest.java'
--- src/test/com/ubuntuone/api/music/GetArtistsTest.java	2012-06-19 01:09:20 +0000
+++ src/test/com/ubuntuone/api/music/GetArtistsTest.java	2012-06-19 01:09:20 +0000
@@ -72,7 +72,7 @@
 		httpResponse = Util.buildResponse(HttpStatus.SC_OK);
 				
 		httpClient = context.mock(HttpClient.class);
-		musicApi = new U1MusicAPI(httpClient, new DummyAuthorizer());
+		musicApi = new U1MusicAPI("ua/1.0", httpClient, new DummyAuthorizer());
 		
 		artistCallback = context.mock(U1ArtistRequestListener.class);
 	}

=== modified file 'src/test/com/ubuntuone/api/music/GetPlaylistTest.java'
--- src/test/com/ubuntuone/api/music/GetPlaylistTest.java	2012-06-19 01:09:20 +0000
+++ src/test/com/ubuntuone/api/music/GetPlaylistTest.java	2012-06-19 01:09:20 +0000
@@ -71,7 +71,7 @@
 		httpResponse = Util.buildResponse(HttpStatus.SC_OK);
 				
 		httpClient = context.mock(HttpClient.class);
-		musicApi = new U1MusicAPI(httpClient, new DummyAuthorizer());
+		musicApi = new U1MusicAPI("ua/1.0", httpClient, new DummyAuthorizer());
 		
 		playlistSongCallback = context.mock(U1PlaylistSongRequestListener.class);
 	}

=== modified file 'src/test/com/ubuntuone/api/music/GetPlaylistsTest.java'
--- src/test/com/ubuntuone/api/music/GetPlaylistsTest.java	2012-06-19 01:09:20 +0000
+++ src/test/com/ubuntuone/api/music/GetPlaylistsTest.java	2012-06-19 01:09:20 +0000
@@ -72,7 +72,7 @@
 		httpResponse = Util.buildResponse(HttpStatus.SC_OK);
 				
 		httpClient = context.mock(HttpClient.class);
-		musicApi = new U1MusicAPI(httpClient, new DummyAuthorizer());
+		musicApi = new U1MusicAPI("ua/1.0", httpClient, new DummyAuthorizer());
 		
 		playlistCallback = context.mock(U1PlaylistRequestListener.class);
 	}

=== added file 'src/test/com/ubuntuone/api/music/GetSongStreamTest.java'
--- src/test/com/ubuntuone/api/music/GetSongStreamTest.java	1970-01-01 00:00:00 +0000
+++ src/test/com/ubuntuone/api/music/GetSongStreamTest.java	2012-06-19 01:09:20 +0000
@@ -0,0 +1,130 @@
+/*
+ * Ubuntu One Music Java library - communicate with Ubuntu One music API
+ * 
+ * Copyright 2012 Canonical Ltd.
+ *   
+ * This file is part of Ubuntu One Files Java library.
+ *  
+ * 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.api.music;
+
+import static com.ubuntuone.test.util.SameHttpRequestMatcher.sameRequest;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+import org.apache.http.HttpHost;
+import org.apache.http.HttpResponse;
+import org.apache.http.HttpStatus;
+import org.apache.http.client.HttpClient;
+import org.apache.http.client.methods.HttpGet;
+import org.apache.http.entity.InputStreamEntity;
+import org.jmock.Expectations;
+import org.jmock.Mockery;
+import org.jmock.Sequence;
+import org.jmock.integration.junit4.JMock;
+import org.jmock.integration.junit4.JUnit4Mockery;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import com.ubuntuone.api.music.client.BaseClient;
+import com.ubuntuone.api.music.client.Failure;
+import com.ubuntuone.api.music.model.U1Song;
+import com.ubuntuone.api.music.util.RequestListener.U1StreamRequestListener;
+import com.ubuntuone.music.util.U1SongBuilder;
+import com.ubuntuone.music.util.Util;
+import com.ubuntuone.test.util.DummyAuthorizer;
+
+@RunWith(JMock.class)
+public class GetSongStreamTest
+{
+	private final Mockery context = new JUnit4Mockery();
+
+	private HttpResponse httpResponse;
+	
+	private HttpHost httpHost =
+			new HttpHost(U1MusicAPI.STREAMING_HOST, -1, BaseClient.HTTPS);
+	
+	private HttpClient httpClient;
+	private U1MusicAPI musicApi;
+	
+	private U1StreamRequestListener streamCallback;
+	
+	@Before
+	public void setUp() throws IOException {
+		httpResponse = Util.buildResponse(HttpStatus.SC_OK);
+				
+		httpClient = context.mock(HttpClient.class);
+		musicApi = new U1MusicAPI("ua/1.0", httpClient, new DummyAuthorizer());
+		
+		streamCallback = context.mock(U1StreamRequestListener.class);
+	}
+	
+	@Test
+	public void testGetSongStreamLifeCycleCallbacks() {
+		U1Song song = new U1SongBuilder().build();
+		long offset = 0L;
+		
+		final Sequence requestSequence = context.sequence("lifecycle");
+		context.checking(new Expectations() {{
+			oneOf(streamCallback).onStart();
+					inSequence(requestSequence);
+			
+			ignoring(httpClient);
+			allowing(streamCallback).onSuccess(with(any(InputStream.class)));
+			allowing(streamCallback).onFailure(with(any(Failure.class)));
+			
+			oneOf(streamCallback).onFinish();
+					inSequence(requestSequence);
+		}});
+		
+		musicApi.getSongStream(song, offset, streamCallback);
+	}
+	
+	@Test
+	public void testGetSongStream() throws IOException {
+		final U1Song song = new U1SongBuilder().build();
+		final long offset = 0L;
+		
+		final HttpGet httpRequest =
+				new HttpGet("https://streaming.one.ubuntu.com/stream/" + song.getId() + "/");
+		
+		String songContent = "song_content";
+		final InputStream instream = new ByteArrayInputStream(songContent.getBytes("UTF-8"));
+		long length = songContent.length();
+		httpResponse.setEntity(new InputStreamEntity(instream, length));
+		
+		final Sequence requestSequence = context.sequence("lifecycle");
+		context.checking(new Expectations() {{
+			oneOf(streamCallback).onStart();
+					inSequence(requestSequence);
+					
+			oneOf(httpClient).execute(with(httpHost), with(sameRequest(httpRequest)));
+					inSequence(requestSequence);
+							will(returnValue(httpResponse));
+			
+			oneOf(streamCallback).onSuccess(with(instream));
+					inSequence(requestSequence);
+			
+			oneOf(streamCallback).onFinish();
+					inSequence(requestSequence);
+		}});
+		
+		musicApi.getSongStream(song, offset, streamCallback);
+	}
+}

=== modified file 'src/test/com/ubuntuone/api/music/GetSongsTest.java'
--- src/test/com/ubuntuone/api/music/GetSongsTest.java	2012-06-19 01:09:20 +0000
+++ src/test/com/ubuntuone/api/music/GetSongsTest.java	2012-06-19 01:09:20 +0000
@@ -72,7 +72,7 @@
 		httpResponse = Util.buildResponse(HttpStatus.SC_OK);
 				
 		httpClient = context.mock(HttpClient.class);
-		musicApi = new U1MusicAPI(httpClient, new DummyAuthorizer());
+		musicApi = new U1MusicAPI("ua/1.0", httpClient, new DummyAuthorizer());
 		
 		songCallback = context.mock(U1SongRequestListener.class);
 	}

=== modified file 'src/test/com/ubuntuone/api/music/PutPlaylistTest.java'
--- src/test/com/ubuntuone/api/music/PutPlaylistTest.java	2012-06-19 01:09:20 +0000
+++ src/test/com/ubuntuone/api/music/PutPlaylistTest.java	2012-06-19 01:09:20 +0000
@@ -72,7 +72,7 @@
 		httpResponse = Util.buildResponse(HttpStatus.SC_OK);
 				
 		httpClient = context.mock(HttpClient.class);
-		musicApi = new U1MusicAPI(httpClient, new DummyAuthorizer());
+		musicApi = new U1MusicAPI("ua/1.0", httpClient, new DummyAuthorizer());
 		
 		playlistSongCallback = context.mock(U1PlaylistSongRequestListener.class);
 	}