Store the sqlite Database into google drive

Mudassir Khan picture Mudassir Khan · Nov 30, 2016 · Viewed 15.1k times · Source

I have tried many example and did not find any good solution.

I want to store the data of my app to store in sqlite database then sync it with the google drive account of the user who installed the app.

There is also a button which will show the data from google drive and user can edit and update the data so the updated data is then store in the google drive. I'm new in Android development please help me.

I also have applied the following example but did not succeed. https://github.com/seanpjanson/GDAADemo Create / Edit / Retrieve DB file with GDAA (Google Drive Api for Android) Unpredictable result of DriveId.getResourceId() in Google Drive Android API https://github.com/googledrive/android-quickstart

Thanks

Answer

Sunil Chaudhary picture Sunil Chaudhary · Nov 30, 2016

first create a db backup in SD-card using below line

Driver_utils.create_backup(SettingActivity.this);

**add below dependencies in build.gradle **

 compile 'com.google.code.gson:gson:2.2.+'
 compile 'com.google.android.gms:play-services-drive:10.0.1'`
in_drive.setOnClickListener(new OnClickListener() {
            @Override
            public void onClick(View v) {
                if (Utils.isInternetWorking()) {
                    File directorys = new File(Environment.getExternalStorageDirectory().getAbsolutePath() + "/Databackup");
                    if (directorys.exists()) {
                        String json = preferences_driverId.getString("drive_id", "");
                        DriveId driveId = gson.fromJson(json, DriveId.class);
                        //Update file already stored in Drive
                        Driver_utils.trash(driveId, google_api_client);
                        // Create the Drive API instance
                        Driver_utils.creatBackupDrive(SettingActivity.this, google_api_client);
                        dialog.dismiss();
                        Toast.makeText(getApplicationContext(), R.string.backupss, Toast.LENGTH_LONG).show();
                    } else {
                        Toast.makeText(getApplicationContext(), R.string.inportfirest, Toast.LENGTH_LONG).show();
                    }
                } else {
                    Toast.makeText(getApplicationContext(), R.string.nointe, Toast.LENGTH_LONG).show();
                }
            }
        });

**And for Restore use this **

   restore_from_drive.setOnClickListener(new OnClickListener() {
        @Override
        public void onClick(View v) {
            // Launch user interface and allow user to select file
            IntentSender intentSender = Drive.DriveApi
                    .newOpenFileActivityBuilder()
                    .setMimeType(new String[]{"application/zip"})
                    .build(google_api_client);
            try {

                startIntentSenderForResult(

                        intentSender, REQ_CODE_OPEN, null, 0, 0, 0);

            } catch (IntentSender.SendIntentException e) {

                Log.w(TAG, e.getMessage());
            }
            dialog.dismiss();
        }
    });

 @Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
    if (requestCode == DIALOG_ERROR_CODE) {
        mResolvingError = false;
        if (resultCode == RESULT_OK) { // Error was resolved, now connect to the client if not done so.
            if (!google_api_client.isConnecting() && !google_api_client.isConnected()) {
                google_api_client.connect();
            }
        }

    }
    if (requestCode == REQ_CODE_OPEN && resultCode == RESULT_OK) {
        DriveId mSelectedFileDriveId = data.getParcelableExtra(
                OpenFileActivityBuilder.EXTRA_RESPONSE_DRIVE_ID);
        Log.e("DriveID ---", mSelectedFileDriveId + "");
        Gson gson = new Gson();
        String json = gson.toJson(mSelectedFileDriveId); // myObject - instance of MyObject
        editor_drive = preferences_driverId.edit();
        editor_drive.putString("drive_id", json).commit();
        Log.e(TAG, "driveId this 1-- " + mSelectedFileDriveId);
        if (Utils.isInternetWorking()) {
            //restore Drive file to SDCArd
            Driver_utils.restoreDriveBackup(SettingActivity.this, google_api_client, GOOGLE_DRIVE_FILE_NAME, preferences_driverId, mfile);
            Driver_utils.restore(SettingActivity.this);

        } else {
            Toast.makeText(getApplicationContext(), R.string.nointernets, Toast.LENGTH_LONG).show();
        }
    }
}

**Make a static Driver_utils class **

public class Driver_utils {
public static DriveFile mfile;
public static GoogleApiClient api;
public static DriveId driveId;
public static Context ctxs;
public static SharedPreferences preferences_driverId;
public static SharedPreferences.Editor editor;
private static final String GOOGLE_DRIVE_FILE_NAME = "Databackup";
public static void restoreDriveBackup(Context ctx, GoogleApiClient apis, String GOOGLE_DRIVE_FILE_NAME, SharedPreferences preferences_driverIds, DriveFile mfiles) {
    mfile = mfiles;
    api = apis;
    preferences_driverId = preferences_driverIds;
    Query query = new Query.Builder()
            .addFilter(Filters.eq(SearchableField.TITLE, GOOGLE_DRIVE_FILE_NAME))
            .build();

    Drive.DriveApi.query(api, query).setResultCallback(new ResultCallback<DriveApi.MetadataBufferResult>() {
        @Override
        public void onResult(DriveApi.MetadataBufferResult metadataBufferResult) {
            Gson gson = new Gson();
            String json = preferences_driverId.getString("drive_id", "");
            DriveId driveId = gson.fromJson(json, DriveId.class);
            Log.e("driveId put", "" + driveId);
            Log.e("filesize in cloud ", +metadataBufferResult.getMetadataBuffer().get(0).getFileSize() + "");
            metadataBufferResult.getMetadataBuffer().release();
            mfile = Drive.DriveApi.getFile(api, driveId);
            mfile.open(api, DriveFile.MODE_READ_ONLY, new DriveFile.DownloadProgressListener() {
                @Override
                public void onProgress(long bytesDown, long bytesExpected) {
                    Log.e("Downloading..", "" + bytesDown + "/" + bytesExpected);
                }
            })
                    .setResultCallback(restoreContentsCallback);
        }
    });
}

static final private ResultCallback<DriveApi.DriveContentsResult> restoreContentsCallback =
        new ResultCallback<DriveApi.DriveContentsResult>() {
            @Override
            public void onResult(DriveApi.DriveContentsResult result) {
                if (!result.getStatus().isSuccess()) {
                    Log.e("Unable to open,try", "data");
                    return;
                }
                File sd = Environment.getExternalStorageDirectory();
                String backupDBPath = "/Databackup.zip";
                File imgFile = new File(sd, backupDBPath);
                Log.e("FILE EXIST", imgFile.exists() + "");

                if (!imgFile.exists())
                    try {
                        imgFile.createNewFile();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                imgFile = new File(imgFile.getAbsolutePath());
                DriveContents contents = result.getDriveContents();
                try {
                    FileOutputStream fos = new FileOutputStream(imgFile.getAbsolutePath());
                    BufferedOutputStream bos = new BufferedOutputStream(fos);
                    BufferedInputStream in = new BufferedInputStream(contents.getInputStream());
                    byte[] buffer = new byte[1024];
                    int n, cnt = 0;
                    while ((n = in.read(buffer)) > 0) {
                        bos.write(buffer, 0, n);
                        cnt += n;
                        Log.e("buffer: ", buffer[0] + "");
                        Log.e("buffer: ", "" + buffer[1]);
                        Log.e("buffer: ", "" + buffer[2]);
                        Log.e("buffer: ", "" + buffer[3]);
                        bos.flush();
                    }

                    bos.close();

                } catch (FileNotFoundException e) {
                    e.printStackTrace();
                } catch (IOException e) {
                    e.printStackTrace();
                }

               //Unzip when download from drive

                try {
                    String dest_file_path = Environment.getExternalStorageDirectory()
                            .getAbsolutePath() + "/Databackup";
                    String src_location = Environment.getExternalStorageDirectory()
                            .getAbsolutePath() + "/Databackup.zip";
                    Decompress.unzip(new File(src_location), new File(dest_file_path));
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        };

public static void creatBackupDrive(Context ctx, GoogleApiClient apis) {
    ctxs = ctx;
    api = apis;
    Drive.DriveApi.newDriveContents(api).setResultCallback(contentsCallback);
}

final public static ResultCallback<DriveApi.DriveContentsResult> contentsCallback = new ResultCallback<DriveApi.DriveContentsResult>() {

    @Override
    public void onResult(DriveApi.DriveContentsResult result) {
        if (!result.getStatus().isSuccess()) {
            Log.e(TAG, "Error while trying to create new file contents");
            return;
        }

        String mimeType = MimeTypeMap.getSingleton().getExtensionFromMimeType("db");
        MetadataChangeSet changeSet = new MetadataChangeSet.Builder()
                .setTitle(GOOGLE_DRIVE_FILE_NAME) // Google Drive File name
                .setMimeType("application/zip")
                .setStarred(true).build();
        // create a file on root folder
        Drive.DriveApi.getRootFolder(api)
                .createFile(api, changeSet, result.getDriveContents())
                .setResultCallback(fileCallback);
    }

};

final public static ResultCallback<DriveFolder.DriveFileResult> fileCallback = new ResultCallback<DriveFolder.DriveFileResult>() {

    @Override
    public void onResult(DriveFolder.DriveFileResult result) {
        preferences_driverId = ctxs.getSharedPreferences("ID", MODE_PRIVATE);
        editor = preferences_driverId.edit();
        if (!result.getStatus().isSuccess()) {
            Log.v(TAG, "Error while trying to create the file");
            return;
        }
        driveId = result.getDriveFile().getDriveId();
        Log.e(TAG, "Created a file with content: " + driveId);
        Gson gson = new Gson();
        String json = gson.toJson(driveId); // myObject - instance of MyObject
        editor.putString("drive_id", json).commit();
        Log.e(TAG, "driveId " + driveId);
        mfile = result.getDriveFile();
        mfile.open(api, DriveFile.MODE_WRITE_ONLY, new DriveFile.DownloadProgressListener() {
            @Override
            public void onProgress(long bytesDownloaded, long bytesExpected) {
                Log.e(TAG, "Creating backup file" + bytesDownloaded + "/" + bytesExpected);
            }
        }).setResultCallback(contentsOpenedCallback);
    }
};
final public static ResultCallback<DriveApi.DriveContentsResult> contentsOpenedCallback = new ResultCallback<DriveApi.DriveContentsResult>() {

    @Override
    public void onResult(DriveApi.DriveContentsResult result) {
        if (!result.getStatus().isSuccess()) {
            Log.v(TAG, "Error opening file");
            return;
        }
        String sd = Environment.getExternalStorageDirectory().getAbsolutePath() + "/DiaryDatabackup.zip";
        Log.e("DB FILE NAME---", sd + "");
        DriveContents contents = result.getDriveContents();
        BufferedOutputStream out = new BufferedOutputStream(contents.getOutputStream());
        byte[] buffer = new byte[1024];
        int n;

        try {
            FileInputStream is = new FileInputStream(sd);
            BufferedInputStream in = new BufferedInputStream(is);

            while ((n = in.read(buffer)) > 0) {
                out.write(buffer, 0, n);
                Log.e("Backing up...", "Backup");
            }
            out.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

        contents.commit(api, null).setResultCallback(new ResultCallback<Status>() {
            @Override
            public void onResult(Status status) {
                Log.e("Backup completed!", "complete"+status);

            }
        });
    }
};
public static  void trash(DriveId dId, GoogleApiClient apis) {
    api = apis;
    try {
        Log.e(TAG,"Goes in trans" );
        DriveFile sumFile = dId.asDriveFile();
        com.google.android.gms.common.api.Status deleteStatus =
                sumFile.delete(api).await();
        if (!deleteStatus.isSuccess()) {
            Log.e(TAG, "Unable to delete app data.");

        } else {
            // Remove stored DriveId.
            preferences_driverId.edit().remove("drive_id").apply();
        }
        Log.d(TAG, "Past sums deleted.");
    } catch (Exception e) {
        e.printStackTrace();
    }
}


public static void restore(Context ctx) {
    OutputStream myOutput;
    String dbpath = "//data//" + ctx.getPackageName() + "//databases//databaseName.db";
    String sdpath = Environment.getExternalStorageDirectory().getAbsolutePath() + "/Databackup";
    File directorys = new File(sdpath + "/backup_sd");
    if (directorys.exists()) {
        try {
            myOutput = new FileOutputStream(Environment.getDataDirectory()
                    + dbpath);
            // Set the folder on the SDcard
            File directory = new File(sdpath + "/backup_sd");
            // Set the input file stream up:
            InputStream myInputs = new FileInputStream(directory.getPath());
            // Transfer bytes from the input file to the output file
            byte[] buffer = new byte[1024];
            int length;
            while ((length = myInputs.read(buffer)) > 0) {
                myOutput.write(buffer, 0, length);
            }
            // Close and clear the streams
            myOutput.flush();
            myOutput.close();
            myInputs.close();
            Toast.makeText(ctx, R.string.successss, Toast.LENGTH_LONG)
                    .show();

        } catch (FileNotFoundException e) {
            Toast.makeText(ctx, ctx.getString(R.string.err), Toast.LENGTH_LONG).show();
            e.printStackTrace();
        } catch (IOException e) {
            Toast.makeText(ctx, ctx.getString(R.string.err), Toast.LENGTH_LONG).show();

            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    } else {
        Log.e("NO DB YET ", "Created");
        Toast.makeText(ctx, R.string.savesome, Toast.LENGTH_LONG).show();

    }

}

public static void create_backup(Context ctx) {
    InputStream myInput;
    String dbpath = "//data//" + ctx.getPackageName() + "//databases//databaseName.db";
    String sdpath_createbackup = Environment.getExternalStorageDirectory().getAbsolutePath() + "/Databackup";
    File file = new File(sdpath_createbackup);
    if (!file.exists())
        file.mkdirs();
    try {

        myInput = new FileInputStream(Environment.getDataDirectory()
                + dbpath);
        // Set the output folder on the Scard
        File directory = new File(file + "/backup_sd");
        // Create the folder if it doesn't exist:
        if (!directory.exists()) {
            directory.createNewFile();
        }
        // Set the output file stream up:
        OutputStream myOutput = new FileOutputStream(directory.getPath());
        // Transfer bytes from the input file to the output file
        byte[] buffer = new byte[100024];
        int length;
        while ((length = myInput.read(buffer)) > 0) {
            myOutput.write(buffer, 0, length);
        }
        // Close and clear the streams
        myOutput.flush();
        myOutput.close();
        myInput.close();
        Toast.makeText(ctx, R.string.backups, Toast.LENGTH_LONG)
                .show();

    } catch (FileNotFoundException e) {
        Toast.makeText(ctx, ctx.getString(R.string.err), Toast.LENGTH_LONG).show();
        Log.e("error", e.getMessage());

        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (IOException e) {
        Toast.makeText(ctx, ctx.getString(R.string.err), Toast.LENGTH_LONG).show();
        Log.e("error 1", e.getMessage());
        // TODO Auto-generated catch block
        e.printStackTrace();

    }
    String src_file_path = Environment.getExternalStorageDirectory()
            .getAbsolutePath() + "/Databackup";
    String destination_location = Environment.getExternalStorageDirectory()
            .getAbsolutePath() + "/Databackup.zip";
    Decompress.backupfolder(new File(src_file_path), new File(destination_location));
  }
}

And You Need Decomposer file just create and Copy this

public class Decompress {

public static  boolean unzip(File zipfile, File directory) {
    BufferedReader br = null;
    try {
        ZipFile zfile = new ZipFile(zipfile);
        Enumeration<? extends ZipEntry> entries = zfile.entries();
        while (entries.hasMoreElements()) {
            ZipEntry entry = entries.nextElement();
            File file = new File(directory, entry.getName());
            if (entry.isDirectory()) {
                file.mkdirs();
            } else {
                file.getParentFile().mkdirs();
                InputStream in = zfile.getInputStream(entry);
                copy(in, file);
                in.close();
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    } finally {
        try {
            if (br != null) br.close();
        } catch (IOException ex) {
            ex.printStackTrace();

        }
    }
    return true;
}


public static boolean backupfolder(File directory, File zipfile) {
    try {
        URI base = directory.toURI();
        Deque<File> queue = new LinkedList<>();
        queue.push(directory);
        OutputStream out = new FileOutputStream(zipfile);
        Closeable res = out;
        ZipOutputStream zout = new ZipOutputStream(out);
        res = zout;
        while (!queue.isEmpty()) {
            directory = queue.pop();
            for (File kid : directory.listFiles()) {
                String name = base.relativize(kid.toURI()).getPath();
                if (kid.isDirectory()) {
                    queue.push(kid);
                    name = name.endsWith("/") ? name : name + "/";
                    zout.putNextEntry(new ZipEntry(name));
                } else {
                    zout.putNextEntry(new ZipEntry(name));
                    copy(kid, zout);
                    zout.closeEntry();
                }
            }
        }
        res.close();
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
    return true;
}

private static void copy(InputStream in, OutputStream out) throws IOException {
    byte[] buffer = new byte[1024];
    while (true) {
        int readCount = in.read(buffer);
        if (readCount < 0) {
            break;
        }
        out.write(buffer, 0, readCount);
    }
}

private static void copy(File file, OutputStream out) throws IOException {
    InputStream in = new FileInputStream(file);
    try {
        copy(in, out);
    } finally {
        in.close();
    }
}

private static void copy(InputStream in, File file) throws IOException {
    OutputStream out = new FileOutputStream(file);
    try {
        copy(in, out);
    } finally {
        out.close();
    }
  }
}