Uploading file to Google Drive in Android Application

    0
    352

    Hi there, In this tutorial, we’ll learn how to upload files to Google Drive, from our application. Some of the examples of its application are uploading captured an image directly to Google drive or uploading an important document to Drive without actually opening the drive from the browser.

    Seems interesting right? So, let’s get started!

    Sample output:

     

    Creating a New Project:

    Open your Android Studio & create a new Project, give name whatever you like and We’ll keep all the things by default and clicked finish.

    Adding permissions to manifest.xml:

    As we are uploading an image to Google Drive using the Internet, We need to ask Internet permission from the user.Add following line in manifest.xml

    <uses-permission android:name="android.permission.INTERNET"/>

    Related:

    Upload Camera images to Firebase Storage in android

    Android Firebase working with Realtime Database and Storage

    Storing And Retrieving Data Using Shared Preferences

    Display current location(latitude and longitude) in google map and save it to the Firebase database in Android

    Periodically send GPS location to Firebase with custom time frame in Android

    Adding Dependencies to Gradle file:

    We need to include toGoogle Play services use Google Drive API.

    compile 'com.google.android.gms:play-services-drive:8.4.0'

    Now you’ve to enable Google Drive API as a developer. For that go to this link: https://developers.google.com/drive/android/get-started  and from there click on set up a project and application in the API Console. Or you can directly click on above 2nd link.

    Create new project there and add your package name and the SHA1 key into the project. Now you are done with configuring Google Drive API. Now add following code to your `MainActivity` file.

    MainActivity.java

    package com.kaushal28.googledrive;
    
    
    import java.io.ByteArrayOutputStream;
    import java.io.IOException;
    import java.io.OutputStream;
    
    import android.app.Activity;
    import android.content.Intent;
    import android.content.IntentSender;
    import android.content.IntentSender.SendIntentException;
    import android.graphics.Bitmap;
    import android.os.Bundle;
    import android.provider.MediaStore;
    import android.util.Log;
    
    import com.google.android.gms.common.ConnectionResult;
    import com.google.android.gms.common.GoogleApiAvailability;
    import com.google.android.gms.common.api.GoogleApiClient;
    import com.google.android.gms.common.api.GoogleApiClient.ConnectionCallbacks;
    import com.google.android.gms.common.api.GoogleApiClient.OnConnectionFailedListener;
    import com.google.android.gms.common.api.ResultCallback;
    import com.google.android.gms.drive.Drive;
    import com.google.android.gms.drive.DriveApi.DriveContentsResult;
    import com.google.android.gms.drive.MetadataChangeSet;
    
    /**
     * Android Drive Quickstart activity. This activity takes a photo and saves it
     * in Google Drive. The user is prompted with a pre-made dialog which allows
     * them to choose the file location.
     */
    public class MainActivity extends Activity implements ConnectionCallbacks,
            OnConnectionFailedListener {
    
        private static final String TAG = "drive-quickstart";
        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;
    
        /**
         * Create a new file and save it to Drive.
         */
        private void saveFileToDrive() {
            // Start by creating a new contents, and setting a callback.
            Log.i(TAG, "Creating new contents.");
            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 bitmapStream = new ByteArrayOutputStream();
                            image.compress(Bitmap.CompressFormat.PNG, 100, bitmapStream);
                            try {
                                outputStream.write(bitmapStream.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("image/jpeg").setTitle("Android Photo.png").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.
                GoogleApiAvailability.getInstance().getErrorDialog(this, result.getErrorCode(), 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");
        }
    }
    

    Here we are uploading the image captured by the user. So when you’ll first time open the application, the app will ask which Google drive you want to use. So select the desired account and the location on the Drive and the file name will be asked as shown in the sample output snapshot. Click okay and the file will be uploaded to your Google Drive.


    If you really liked the article, please subscribe to our YouTube Channel for videos related to this article.Please find us on Twitter and Facebook.

    LEAVE A REPLY

    Please enter your comment!
    Please enter your name here