Friday, October 5, 2018

Google Drive REST API V3 > Upload / Insert / Create Files Into Google Drive

So the very first step to upload a file to google drive using REST API V3, you need to create a project into your google account, then create a API key / value pair to authorize your application.

Follow below link to create your application and authorize your application:

CLICK HERE FOR MORE DETAILS

So at this stage, I assumed that you already have ACCESS KEY, which is the only thing when you communicate with Google REST API.

Below are some code snippet written in JAVA to upload files into GOOGLE DRIVE, you can do that same in other language, because I am not using any CLIENT LIBRARY, it's RAW REST API
The below link is GOOGLE DRIVE REST API V3 documentation link
CLICK HERE FOR MORE DETAILS

BELOW IS A FULL CODE SNIPPET TO UPLOAD/CREATE A FILE INTO GOODLE DRIVE USING REST API V3

package com.pkm;

import java.io.*;
import java.net.URL;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import sun.misc.BASE64Encoder;

import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;

/**
 * Created by [PRITOM KUMAR] on 05-Oct-18.
 */
public class GoogleDriveFileUpload {
    public static void main(String[] args) throws Exception {
        /* I assumed you already have ACCESS TOKEN */
        String AUTH_TOKEN = "ya29...………….._BmTq3YOBNmQ";

        /* Collect your bytes from any file */
        byte[] content = "SUCCEED".getBytes(Charset.defaultCharset());

        /* JSON ENCODED PARAMS [name: 'Mine.txt', mimeType: 'text/plain'] */
        String params = "{\"name\":\"Mine.txt\",\"mimeType\":\"text\\/plain\"}";

        String boundary = "=====" + System.currentTimeMillis() + "============";
        String postBody = "--" + boundary + "\n" +
                "Content-Type: application/json; charset=UTF-8\n\n\n" +
                params + "\n" +
                "--" + boundary + "\n" +
                "Content-Type: text/plain\n" +
                "Content-Transfer-Encoding: base64\n\n\n" +
                base64Encode(content) +
                "\n--" + boundary + "--";

        String URI = "https://www.googleapis.com/upload/drive/v3/files?uploadType=multipart";
        Map headers = new HashMap();
        headers.put("content-type", "multipart/related; boundary=" + boundary);
        headers.put("Content-Transfer-Encoding", "binary");
        headers.put("MIME-Version", "1.0");
        headers.put("Authorization", "Bearer " + AUTH_TOKEN);

        Map result = HttpJavaClient.doPost(URI, postBody, HttpJavaClient.Type.HTTP, headers);

        System.out.println(result);
        File outputFile = (File) result.get("outputFile");
        if (outputFile != null) {
            List<String> lines = Files.readAllLines(outputFile.toPath(), Charset.defaultCharset());
            for (String line : lines) {
                System.out.println(line);
            }
        }
    }

    public static String base64Encode(byte[] data) {
        BASE64Encoder base64Encoder = new BASE64Encoder();
        return base64Encoder.encodeBuffer(data);
    }
}

class HttpJavaClient {
    public static enum Method {
        GET, POST, PUT, PATCH, DELETE
    }

    public static enum Type {
        XML, JSON, URL_ENCODED, HTTP;
    }

    public static Map doPost(String url, String data, Type type, Map headers) {
        return execute(url, Method.POST, data, type, headers, null);
    }

    private static Map execute(String requestURL, Method requestMethod, String requestData, Type dataType, Map headers, Integer timeOutMilli) {
        String httpResponse = "", responseMessage = "";
        Integer httpCode = 0;
        timeOutMilli = timeOutMilli == null ? 1000 * 30 : timeOutMilli; /* Default read & write timeout */

        Map r = new HashMap();
        HttpsURLConnection connection = null;
        try {
            String contentType = "", accept = "", contentLength = "" + requestData.length();
            switch (dataType) {
                case XML:
                    contentType = "text/xml; charset=utf-8";
                    accept = "text/xml";
                    break;
                case JSON:
                    contentType = "application/json";
                    break;
                case URL_ENCODED:
                    contentType = "application/x-www-form-urlencoded";
                    break;
            }

            connection = (HttpsURLConnection) new URL(requestURL).openConnection();
            connection.setRequestMethod(requestMethod.name());
            connection.setConnectTimeout(timeOutMilli);
            connection.setReadTimeout(timeOutMilli);
            connection.setRequestProperty("Pragma", "no-cache");

            if (headers != null && headers.size() > 0) {
                for (Object name : headers.keySet().toArray()) {
                    if (name.toString().endsWith("tls")) {
                        //headers.put("tls", "TLSv1.2");
                        //headers.put("tls", "TLSv1");
                        SSLContext sc = SSLContext.getInstance(headers.get(name.toString()).toString());
                        sc.init(null, null, new java.security.SecureRandom());
                        connection.setSSLSocketFactory(sc.getSocketFactory());
                    }
                    else {
                        connection.setRequestProperty(name.toString(), headers.get(name.toString()).toString());
                    }
                }
            }

            if (requestData.length() > 0) {
                connection.setDoInput(true);
                connection.setDoOutput(true);

                if (accept.length() > 0) {
                    connection.setRequestProperty("Accept", accept);
                }
                if (contentType.length() > 0) {
                    connection.setRequestProperty("Content-Type", contentType);
                }

                connection.setRequestProperty("Content_length", contentLength);
                OutputStreamWriter writer = new OutputStreamWriter(connection.getOutputStream(), "UTF-8");
                writer.write(requestData);
                writer.flush();
                writer.close();
            }

            httpCode = connection.getResponseCode();
            responseMessage = connection.getResponseMessage();

            if (httpCode >= 200 && httpCode <= 299) {
                String responseContentType = connection.getContentType();
                if (responseContentType == null || responseContentType.length() == 0) {
                    responseContentType = "txt";
                }
                else {
                    if (responseContentType.contains(";")) {
                        responseContentType = responseContentType.substring(0, responseContentType.indexOf(";"));
                    }
                    if (responseContentType.contains("text/html")) {
                        responseContentType = "html";
                    }
                    else if (responseContentType.contains("image/")) {
                        responseContentType = "image";
                    }
                    else if (responseContentType.contains("/")) {
                        String[] parts = responseContentType.split("/");
                        responseContentType = parts[parts.length - 1];
                    }
                }
                Map<String, List<String>> map = connection.getHeaderFields();
                for (Map.Entry<String, List<String>> entry : map.entrySet()) {
                    System.out.println("Key=" + entry.getKey() + " ,Value=" + entry.getValue());
                }
                System.out.println("Key=ResponseType ,Value=" + responseContentType);

                File tempFile = File.createTempFile("hello", ".tmp");
                RandomAccessFile output = new RandomAccessFile(tempFile, "rw");

                InputStream is = connection.getInputStream();
                BufferedInputStream input = new BufferedInputStream(is);


                Integer fileLength = connection.getContentLength();
                int readSize = 1024, downloadedSize = 0;
                byte data[] = new byte[readSize];
                int count = 0;
                int progress = 0;

                Long timeNeeded = System.currentTimeMillis();
                while ((count = input.read(data, 0, readSize)) >= 0 && progress != 100)
                {
                    downloadedSize += count;
                    output.write(data, 0, count);
                    progress = (int) ((downloadedSize * 100) / fileLength);
                    Long mb = output.length() / (1024 * 1024);
                    System.out.println("PROGRESS = " + (progress) + "%, DOWNLOADED=" + mb + " MB, TYPE=" + responseContentType);
                }
                output.close();
                input.close();
                r.put("outputFile", tempFile);

                timeNeeded = (System.currentTimeMillis() - timeNeeded) / 1000;
                System.out.println("TIME REQUIRED=" + timeNeeded + " SECONDS!!!");
            }
        }
        catch (Exception ex) {
            httpResponse = "";
            responseMessage = ex.getMessage();
        }
        finally {
            try {
                connection.disconnect();
            }
            catch (Exception ex10) {
            }
        }
        r.put("code", httpCode);
        r.put("message", responseMessage);
        r.put("output", httpResponse);
        return r;
    }
}
And output / response from GOOGLE DRIVE REST API V3 is as below:
{
    "kind": "drive#file",
    "id": "1KRehy6fX-6WwWi4AAERUklXki8EqwoWh",
    "name": "Mine.txt",
    "mimeType": "text/plain"
}

2 comments:

  1. Hi,
    Thank you for your contribution.
    Could you tell me if it's possible to upload a folder to Google Drive with this implantation?

    ReplyDelete
    Replies
    1. You can create a folder using API and then can upload files to that folder.

      Delete