Store the sqlite Database into google drive

Question

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 o

Answer 1

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() {
        @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 restoreContentsCallback =
        new ResultCallback() {
            @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 contentsCallback = new ResultCallback() {

    @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 fileCallback = new ResultCallback() {

    @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 contentsOpenedCallback = new ResultCallback() {

    @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() {
            @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 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 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();
    }
  }
}