Android resumable upload to Google Drive

Question

I am testing the Drive API for Android to upload a file that can show uploaded progress and be able to resume the upload if it fails (Files size > 30 MB.)

With the following questions: Uploading Downloading of large size file to Google Drive giving error, Upload progress listener not fired (Google drive API) I was able to get the upload progress and they mention those are resumable uploads. However, I don't see any code that looks for an upload error and resume logic, thus if I kill the application and "resume" the upload, it simply starts from the beginning.

This is my code:

public class DriveScreen extends BaseDriveActivity {
    private Drive service;
    private Context context;
    @Override
    public void onConnected(Bundle connectionHint) {
        super.onConnected(connectionHint);
        context = this;

        //https://stackoverflow.com/questions/17429798/usingoauth2-deprecated
        GoogleAccountCredential credential = GoogleAccountCredential.usingOAuth2(this, Arrays.asList(DriveScopes.DRIVE_FILE));
        credential.setSelectedAccountName("accountNameHERE");
        service = new Drive.Builder(AndroidHttp.newCompatibleTransport(), new GsonFactory(), credential).build();
        UploadFile();
    }

    public void UploadFile() {
        AsyncTask<Void, Long, String> task = new AsyncTask<Void, Long, String>() {
            java.io.File fileContent;
            FileContent mediaContent;
            com.google.api.services.drive.model.File body;
            com.google.api.services.drive.model.File file;
            private ProgressDialog mDialog;
            long mFileLen;

            @Override
            protected void onPreExecute() {
                // TODO Auto-generated method stub
                super.onPreExecute();
                mDialog = new ProgressDialog(context);
                mDialog.setMax(100);
                mDialog.setMessage("Uploading ");
                mDialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
                mDialog.setProgress(0);
                mDialog.setButton("Cancel", new OnClickListener() {

                    @Override
                    public void onClick(DialogInterface arg0, int arg1) {
                        // TODO Auto-generated method stub

                    }
                });
                mDialog.show();
            }

            class FileUploadProgressListener implements MediaHttpUploaderProgressListener {

                @Override
                public void progressChanged(MediaHttpUploader uploader) throws IOException {
                    Log.d("Percent ", String.valueOf(uploader.getProgress()));
                    switch (uploader.getUploadState()) {
                    case INITIATION_STARTED:
                        System.out.println("Initiation Started");
                        break;
                    case INITIATION_COMPLETE:
                        System.out.println("Initiation Completed");
                        break;
                    case MEDIA_IN_PROGRESS:
                        System.out.println("Upload in progress");
                        System.out.println("Upload percentage: " + uploader.getProgress());
                        mDialog.setProgress((int) (uploader.getProgress()*100));
                        break;
                    case MEDIA_COMPLETE:
                        System.out.println("Upload Completed!");
                        break;
                    case NOT_STARTED:
                        System.out.println("Upload Not Started!");
                        break;
                    }
                }
            }

            @Override
            protected String doInBackground(Void... arg0) {
                try {
                    File folder = Environment.getExternalStoragePublicDirectory(
                            Environment.DIRECTORY_PICTURES
                        );
                    File UPLOAD_FILE = new File(folder, "filePathHERE");
                    fileContent = new File(folder, "filePathHERE");
                    mFileLen = fileContent.length();

                    InputStreamContent mediaContent2 = new InputStreamContent("application/zip", new FileInputStream(UPLOAD_FILE));
                    mediaContent2.setLength(UPLOAD_FILE.length());
                    body = new com.google.api.services.drive.model.File();
                    body.setTitle(fileContent.getName());
                    body.setMimeType("application/zip");
                    //String parentId = null;
                    //int x = Files.List.setQ("mimeType = 'application/vnd.google-apps.folder' and title = 'ShareHim'");
                    //body.setParents(Arrays.asList(new ParentReference().setId(uploadFile.getFileHostFolderId())));



                    Files.Insert mInsert = service.files().insert(body, mediaContent2);
                    if(mFileLen > 5 * 1024 * 1024)
                    {
                        MediaHttpUploader uploader = mInsert.getMediaHttpUploader();
                        uploader.setDirectUploadEnabled(false);
                        uploader.setChunkSize(MediaHttpUploader.MINIMUM_CHUNK_SIZE);
                        uploader.setProgressListener(new FileUploadProgressListener());
                        file = mInsert.execute();
                        if (file != null) {

                        }
                    }
                    else {
                        mInsert.execute();
                    }
                } catch (UserRecoverableAuthIOException e) {
                    System.out.println("login error");
                    Log.d("Error", "not login " + e);
                } catch (IOException e) {
                    e.printStackTrace();
                }
                return null;
            }


            protected void onPostExecute(String result) {
                mDialog.dismiss();
            };
        };
        task.execute();
    }
}

Now, it is uploading by chunks, but how can we resume the upload from the last chunk sent. My first impression after watching Google Drive talks on youtube was that the resumable upload was handled automatically, but it doesn't seem to be the case.

Am I approaching this the wrong way? Is it worth considering using a DriveSyncAdapter to upload a file as an alternative? (Sorry for the bad code, this is just a test)

Answer 1

It looks like you are using the Java REST-ful API. If you use the Android-specific API, this is all handled for you. Just hand over the file, and the API will do resumable upload as appropriate. See creating files.