在Android中下载Google云端硬盘图像的最有效方法是什么？

Question

I'm writing an app which requires that images be downloaded from a Google Drive. I am currently doing this using the following code:

protected void downloadFromDrive(Context context) {
    InputStream input = null;
    FileOutputStream output = null;
    try {
        HttpRequest request = GoogleDriveWorker.get(context)
        .getDrive()
        .getRequestFactory()
        .buildGetRequest(new GenericUrl(getUri()));
        input = request.execute().getContent();
        output = context.openFileOutput(getImageFilename(), Context.MODE_PRIVATE);
        int bufferSize = 1024;
        byte[] buffer = new byte[bufferSize];
        int len = 0;
        while ((len = input.read(buffer)) != -1) {
            output.write(buffer, 0, len);
        }
    } catch (UnrecoverableKeyException e) {
        e.printStackTrace();
    } catch (NoSuchAlgorithmException e) {
        e.printStackTrace();
    } catch (CertificateException e) {
        e.printStackTrace();
    } catch (KeyStoreException e) {
        e.printStackTrace();
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            if(output!=null)
                output.close();
            if(input!=null)
                input.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

public String getUri() {
    return mUri;
}

GoogleDriveWorker is just a class that gets a google drive with the credentials we're using. Anyway, most of the examples I can find use this basic structure to download a file from an InputStream and put it to an OutputStream , but the download rate is rather slow.

Firstly, can I speed it up by using a more sophisticated method than synchronously buffering the InputStream to the OutputStream a kilobyte at a time? It strikes me that I should try to read the InputStream on a different thread, and output to the OutputStream as kilobyte chunks become available using a queue of chunks. Tying the read code and the write code together seems clunky, and they will surely slow each other down.

Secondly, would changing the buffer size affect the data rate at all? A kilobyte seems small, but on a mobile connection maybe it's not that small. Then again the larger the chunk, the larger the wait from each section of the read/write loop. Is using a different-sized buffer worth considering?

Answer 1

I don't think there's a more sophisticated method than what you did. You could probably make some experiments with larger chunks (for example few hundred KB) and measure the tiem. I think it was faster.

Also check the drive/java-api-client-library documentation about the chunk size. I think there was some explanation about it, but I'm not 100% sure about that.