Upload text file to Google Drive using Android

Question

Edited: I have set my text into a string like so:

String text = ("Hello!");

I want to turn this into a plain text file and then upload to a Google Drive Folder. I have tried on the code below, but it is not complete so I cannot say what errors appear.

I am using the Google Drive "Quick-start" Demo, and trying to tailor it for what I need. Link: https://github.com/googledrive/android-quickstart

DriverClass:

public class UploadDrive extends Activity implements ConnectionCallbacks,OnConnectionFailedListener {

 private static final String TAG = "androiddrivequickstart";
 private static final int REQUEST_CODE_CAPTURE_IMAGE = 1;
 private static final int REQUEST_CODE_CREATOR = 2;
 private static final int REQUEST_CODE_RESOLUTION = 3;
 private GoogleApiClient mGoogleApiClient;
 private Bitmap mBitmapToSave;


 private void saveFileToDrive() {
    // Start by creating a new contents, and setting a callback.
    Log.i(TAG, "Creating new contents.");
    //How to call? Can i use File from java.io?
    final Bitmap image = mBitmapToSave;
    Drive.DriveApi.newDriveContents(mGoogleApiClient).setResultCallback(new ResultCallback<DriveContentsResult>() {

        @Override
        public void onResult(DriveContentsResult result) {
            // If the operation was not successful, we cannot do anything
            // and must
            // fail.
            if (!result.getStatus().isSuccess()) {
                Log.i(TAG, "Failed to create new contents.");
                return;
            }
            // Otherwise, we can write our data to the new contents.
            Log.i(TAG, "New contents created.");
            // Get an output stream for the contents.

            OutputStream outputStream = result.getDriveContents().getOutputStream();

            // Write the bitmap data from it.
            ByteArrayOutputStream textFile = new ByteArrayOutputStream();
            //image.compress(Bitmap.CompressFormat.PNG, 100, textFile);
            try {
                outputStream.write(textFile.toByteArray());
            } catch (IOException e1) {
                Log.i(TAG, "Unable to write file contents.");
            }
            // Create the initial metadata - MIME type and title.
            // Note that the user will be able to change the title later.
            MetadataChangeSet metadataChangeSet = new MetadataChangeSet.Builder()
                    .setMimeType("text/plain").setTitle("Log: test.txt").build();
            // Create an intent for the file chooser, and start it.
            IntentSender intentSender = Drive.DriveApi
                    .newCreateFileActivityBuilder()
                    .setInitialMetadata(metadataChangeSet)
                    .setInitialDriveContents(result.getDriveContents())
                    .build(mGoogleApiClient);
            try {
                startIntentSenderForResult(
                        intentSender, REQUEST_CODE_CREATOR, null, 0, 0, 0);
            } catch (SendIntentException e) {
                Log.i(TAG, "Failed to launch file chooser.");
            }
        }
    });
}

@Override
protected void onResume() {
    super.onResume();
    if (mGoogleApiClient == null) {
        // Create the API client and bind it to an instance variable.
        // We use this instance as the callback for connection and connection
        // failures.
        // Since no account name is passed, the user is prompted to choose.
        mGoogleApiClient = new GoogleApiClient.Builder(this)
                .addApi(Drive.API)
                .addScope(Drive.SCOPE_FILE)
                .addConnectionCallbacks(this)
                .addOnConnectionFailedListener(this)
                .build();
    }
    // Connect the client. Once connected, the camera is launched.
    mGoogleApiClient.connect();
}

@Override
protected void onPause() {
    if (mGoogleApiClient != null) {
        mGoogleApiClient.disconnect();
    }
    super.onPause();
}

@Override
protected void onActivityResult(final int requestCode, final int resultCode, final Intent data) {
    switch (requestCode) {
        case REQUEST_CODE_CAPTURE_IMAGE:
            // Called after a photo has been taken.
            if (resultCode == Activity.RESULT_OK) {
                // Store the image data as a bitmap for writing later.
                mBitmapToSave = (Bitmap) data.getExtras().get("data");
            }
            break;
        case REQUEST_CODE_CREATOR:
            // Called after a file is saved to Drive.
            if (resultCode == RESULT_OK) {
                Log.i(TAG, "Image successfully saved.");
                mBitmapToSave = null;
                // Just start the camera again for another photo.
                startActivityForResult(new Intent(MediaStore.ACTION_IMAGE_CAPTURE),REQUEST_CODE_CAPTURE_IMAGE);
            }
            break;
    }
}

@Override
public void onConnectionFailed(ConnectionResult result) {
    // Called whenever the API client fails to connect.
    Log.i(TAG, "GoogleApiClient connection failed: " + result.toString());
    if (!result.hasResolution()) {
        // show the localized error dialog.
        GooglePlayServicesUtil.getErrorDialog(result.getErrorCode(), this, 0).show();
        return;
    }
    // The failure has a resolution. Resolve it.
    // Called typically when the app is not yet authorized, and an
    // authorization
    // dialog is displayed to the user.
    try {
        result.startResolutionForResult(this, REQUEST_CODE_RESOLUTION);
    } catch (SendIntentException e) {
        Log.e(TAG, "Exception while starting resolution activity", e);
    }
}

@Override
public void onConnected(Bundle connectionHint) {
    Log.i(TAG, "API client connected.");
    if (mBitmapToSave == null) {
        // This activity has no UI of its own. Just start the camera.
        startActivityForResult(new Intent(MediaStore.ACTION_IMAGE_CAPTURE),
                REQUEST_CODE_CAPTURE_IMAGE);
        return;
    }
    saveFileToDrive();
}

@Override
public void onConnectionSuspended(int cause) {
    Log.i(TAG, "GoogleApiClient connection suspended");
}
 }

How do I call the finalResultText which is in another class called MainActivity so I can make it into a plain text file to be uploaded to a Google Drive folder?

Answer 1

Assuming that you question is: 'How do I upload a text file to Google Drive?', here is the quick overview:

1/ Get your app authorized on developers console, see this. Basically, tell Google that your app represented by SHA1 / 'package-name' needs access to Drive API (don't forget your email address on the consent screen). This authorization is good for both REST and GDAA api.

2/ Decide if you want to use REST or GDAA API to access the Drive. Each has advantages/disadvantages (but it's a long story).

3/ Take a look at the REST/GDAA wrapper demo here, it has the app authorization process in the MainActivity class (see onConnFail() method), and basic CRUD methods for both REST and GDAA in their respective classes.

Good Luck

UPDATE
Based on your comments below, I assume you want to force the QuickStart demo to work for you. Keep in mind that GDAA (or REST) don't care what the content is It is just a bunch of bytes. So, as QuickStart turns the Bitmap into PNG and feeds the output stream with it's bytes, you have to do it with your bunch-of-bytes. I quickly smacked together 2 primitives below, that would feed the DriveContents' output stream with file or byte array (and you can turn whatever you've got into a file or byte[]).

 DriveContents file2Cont(DriveContents driveContents, java.io.File file) {
    OutputStream oos = driveContents.getOutputStream();
    if (oos != null) try {
      InputStream is = new FileInputStream(file);
      byte[] buf = new byte[8192];
      int c = 0;
      while ((c = is.read(buf, 0, buf.length)) > 0) {
        oos.write(buf, 0, c);
        oos.flush();
      }
    } catch (Exception e)  {/*handle errors*/}
    finally {
      try {
        oos.close();
      } catch (Exception ignore) { }
    }
    return driveContents;
  }

  DriveContents bytes2Cont(DriveContents driveContents, byte[] buf) {
    OutputStream os = driveContents.getOutputStream();
    try { os.write(buf);
    } catch (IOException e)  {/*handle errors*/}
     finally {
      try { os.close();
      } catch (Exception e) {/*handle errors*/}
    }
    return driveContents;
  }