Throwing the Exception But Using the Finally Block Does this piece of code make sense? The idea is to throw any exceptions that may occur but always run the finally block to close the streams. 

private void streamToFile(HttpResponse transferResponse) throws Exception {
    OutputStream output = null;
    InputStream input = null;
    try {
        input = new BufferedInputStream(transferResponse.getEntity().getContent());
        output = new FileOutputStream(transferFile);
        final int BUFFER_SIZE = 1024*10;
        byte data[] = new byte[BUFFER_SIZE];
        int count;
        while ((count = input.read(data)) != -1) {
            output.write(data, 0, count);
            publishProgress(count);
            remainingBytes = remainingBytes - count;
        }
    } finally {
        input.close();
        output.close();
    }
}
You could use the closeQuietly methods of IOUtils (Apache Commons IO) (or similar ones) for input streams. It ignores exceptions and accepts null values.

Its implementation is just a few lines of code, so you can copy it directly to your Android application without the jar file:

public static void closeQuietly(Closeable closeable) {
    try {
        if (closeable != null) {
            closeable.close();
        }
    } catch (IOException ioe) {
        // ignore
    }
}


You could also create a close method for ouput streams:

public static void closeQuietly(OutputStream stream) throws IOException {
    if (stream != null) {
        stream.close();
    }
}


Both methods accept null values which means that you can call them with null, closeQuietly and close will handle that and you don't have to check null values in the finally block:

} finally {
    if (input != null) {
        closeQuietly(input);
    }
    close(output);
}


Instead of this the following is completely enough:

} finally {
    closeQuietly(input);
    close(output);
}


It's much simpler.

closeQuietly ignores exceptions which means that it catches them but don't do anything with them. Notice the empty catch block:

    } catch (IOException ioe) {
        // ignore
    }


It ensures that if closeable.close() throws an IOException the close(output) will run and it will close the output stream too.

I'm a little bit paranoid about this so I always put a logging statement to the catch block:

    } catch (IOException ioe) {
        logger.warn("Could not close the stream", ioe);
    }


To be honest, I've never seen this exception, so I think it's safe to left this block empty.

Ignoring IOExceptions of output streams could be dangerous: you might miss a bug and get a corrupted output file.