Android 驱动器API-下载/上载sql数据库

我现在正在下载我用驱动api上传的sql数据库。确实有一个备份，但是当我试图打开文件时，我得到一个错误，文件无法打开

编辑： 我解决了上面的问题。 现在我想最后上传和下载sql数据库

我在网上找到了可以下载和上传的代码，但什么都没用

如何正确上载和下载sql数据库

我的代码：

public static void restoreDriveBackup() {
    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) {
            int count = metadataBufferResult.getMetadataBuffer().getCount() - 1;
            debug("Count: " + count);
            driveId = metadataBufferResult.getMetadataBuffer().get(count).getDriveId();
            debug("driveId: " + driveId);
            metadataBufferResult.getMetadataBuffer().release();

            mfile = Drive.DriveApi.getFile(api, driveId);

            mfile.open(api, DriveFile.MODE_READ_ONLY, new DriveFile.DownloadProgressListener() {
                @Override
                public void onProgress(long l, long l1) {
                    debug("Downloading... ("+l+")");
                }
            })
                    .setResultCallback(restoreContentsCallback);
        }
    });
}

public static void doDriveBackup() { Drive.DriveApi.newContents(api).setResultCallback(backupContentsCallback); }

static final private ResultCallback<DriveApi.DriveContentsResult> restoreContentsCallback =
        new ResultCallback<DriveApi.DriveContentsResult>() {
            @Override
            public void onResult(DriveApi.DriveContentsResult result) {
                if (!result.getStatus().isSuccess()) {
                    mToast("File cant be opened");
                    return;
                }

                utilsM.dbClose();

                DriveContents contents = result.getDriveContents();
                File db_file;

                InputStreamReader is = new InputStreamReader(contents.getInputStream());
                BufferedReader reader = new BufferedReader(new InputStreamReader(contents.getInputStream());

                FileOutputStream fos; 
                String line;

                db_file = getDbPath();

                if (db_file != null) {
                    db_file.delete();
                }

                try {
                    fos = new FileOutputStream(act.getDatabasePath(DATABASE_NAME));

                    while ((line = reader.readLine()) != null) { fos.write(line.getBytes()); }
                    fos.flush();
                    fos.close();
                } catch (FileNotFoundException e) {
                    e.printStackTrace();
                } catch (IOException e) {
                    e.printStackTrace();
                }

                utilsM.dbOpen();
                mRecyclerView.invalidate();
                mAdapter.notifyDataSetChanged();
                contents.discard(api);

            }
        };




static final private ResultCallback<DriveApi.DriveContentsResult> backupContentsCallback = new ResultCallback<DriveApi.DriveContentsResult>() {

    @Override
    public void onResult(DriveApi.DriveContentsResult result) {
        if (!result.getStatus().isSuccess()) {
            mToast("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(mimeType)
                .setStarred(true).build();
        // create a file on root folder
        Drive.DriveApi.getRootFolder(api)
                .createFile(api, changeSet, result.getDriveContents())
                .setResultCallback(backupFileCallback);
    }
};
static final private ResultCallback<DriveFolder.DriveFileResult> backupFileCallback = new ResultCallback<DriveFolder.DriveFileResult>() {
    @Override
    public void onResult(DriveFolder.DriveFileResult result) {
        if (!result.getStatus().isSuccess()) {
            mToast("Error while trying to create the file");
            return;
        }
        mfile = result.getDriveFile();
        mfile.open(api, DriveFile.MODE_WRITE_ONLY, null).setResultCallback(backupContentsOpenedCallback);
    }
};
static final private ResultCallback<DriveApi.DriveContentsResult> backupContentsOpenedCallback = new ResultCallback<DriveApi.DriveContentsResult>() {
    @Override
    public void onResult(DriveApi.DriveContentsResult result) {
        if (!result.getStatus().isSuccess()) {
            mToast("Error opening file");
            return;
        }
        try {
            mToast("Uploading db...");

            DriveContents content = result.getDriveContents();
            FileInputStream is = new FileInputStream(act.getDatabasePath(DATABASE_NAME));

            BufferedInputStream in = new BufferedInputStream(is);
            BufferedOutputStream out = new BufferedOutputStream(content.getOutputStream());

            byte[] buffer = new byte[4 * 1024];
            int n = 0;
            int off = 0;

            while( ( n = in.read(buffer) ) > 0) {
                out.write(buffer, 0, n);
                off += n;
                debug("upload_buffer: " + buffer[0]);
                debug("upload_n: " + n);
            }

            debug("writen len: "+off);

            in.close();
            is.close();
            out.flush();
            out.close();
            content.commit(api, null).setResultCallback(new ResultCallback<Status>() {
                @Override
                public void onResult(Status status) {
                    mToast("Upload successfull!");
                }
            });
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
};

publicstaticvoid restoreDriveBackup（）{
Query Query=new Query.Builder（）
.addFilter（Filters.eq（SearchableField.TITLE，GOOGLE\u DRIVE\u FILE\u NAME））
.build（）；
Drive.DriveApi.query（api，query）.setResultCallback（new-ResultCallback（））{
@凌驾
public void onResult（DriveApi.MetadataBufferResult MetadataBufferResult）{
int count=metadataBufferResult.getMetadataBuffer（）.getCount（）-1；
调试（“计数：”+Count）；
driveId=metadataBufferResult.getMetadataBuffer（）.get（计数）.getDriveId（）；
调试（“driveId:+driveId”）；
metadataBufferResult.getMetadataBuffer（）.release（）；
mfile=Drive.DriveApi.getFile（api，driveId）；
打开（api，DriveFile.MODE_只读，new DriveFile.DownloadProgressListener（）{
@凌驾
公共工程进展（长l、长l1）{
调试（“下载…（“+l+”））；
}
})
.setResultCallback（restoreContentsCallback）；
}
});
}
public static void doDriveBackup（）{Drive.DriveApi.newContents（api.setResultCallback（backupContentsCallback）；}
静态最终私有结果回调restoreContentsCallback=
新的ResultCallback（）{
@凌驾
public void onResult（DriveApi.DriveContentsResult结果）{
如果（！result.getStatus（）.issucess（））{
mToast（“无法打开文件”）；
返回；
}
utilsM.dbClose（）；
DriveContents=result.getDriveContents（）；
文件db_文件；
InputStreamReader is=新的InputStreamReader（contents.getInputStream（））；
BufferedReader=new BufferedReader（new InputStreamReader（contents.getInputStream（））；
文件输出流；
弦线；
db_file=getDbPath（）；
if（db_文件！=null）{
db_file.delete（）；
}
试一试{
fos=新文件输出流（act.getDatabasePath（数据库名称））；
而（（line=reader.readLine（））！=null）{fos.write（line.getBytes（））；}
fos.flush（）；
fos.close（）；
}catch（filenotfounde异常）{
e、 printStackTrace（）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}
utilsM.dbOpen（）；
mRecyclerView.invalidate（）；
mAdapter.notifyDataSetChanged（）；
内容。废弃（api）；
}
};
静态最终私有ResultCallback backupContentsCallback=新ResultCallback（）{
@凌驾
public void onResult（DriveApi.DriveContentsResult结果）{
如果（！result.getStatus（）.issucess（））{
mToast（“尝试创建新文件内容时出错”）；
返回；
}
字符串mimeType=MimeTypeMap.getSingleton（）.getExtensionFromMimeType（“db”）；
MetadataChangeSet changeSet=新建MetadataChangeSet.Builder（）
.setTitle（谷歌驱动器文件名）//谷歌驱动器文件名
.setMimeType（mimeType）
.setStarred（true）.build（）；
//在根文件夹上创建文件
Drive.DriveApi.getRootFolder（api）
.createFile（api、变更集、结果.getDriveContents（））
.setResultCallback（backupFileCallback）；
}
};
静态最终私有ResultCallback backupFileCallback=new ResultCallback（）{
@凌驾
public void onResult（DriveFolder.DriveFileResult）{
如果（！result.getStatus（）.issucess（））{
mToast（“尝试创建文件时出错”）；
返回；
}
mfile=result.getDriveFile（）；
mfile.open（api，DriveFile.MODE_WRITE_ONLY，null）.setResultCallback（backupContentsOpenedCallback）；
}
};
静态最终私有ResultCallback backupContentsOpenedCallback=新ResultCallback（）{
@凌驾
public void onResult（DriveApi.DriveContentsResult结果）{
如果（！result.getStatus（）.issucess（））{
mToast（“打开文件时出错”）；
返回；
}
试一试{
mToast（“上传数据库…”）；
DriveContents=result.getDriveContents（）；
FileInputStream是=新的FileInputStream（act.getDatabasePath（数据库名称））；
BufferedInputStream in=新的BufferedInputStream（is）；
BufferedOutputStream out=新的BufferedOutputStream（content.getOutputStream（））；
字节[]缓冲区=新字节[4*1024]；
int n=0；
int off=0；
而（（n=in.read（buffer））>0）{
out.write（缓冲区，0，n）；
off+=n；
调试（“上传缓冲区：+缓冲区[0]）；
调试（“上载n:+n”）；
}
调试（“写入透镜：+关闭”）；
in.close（）；
is.close（）；
out.flush（）；
out.close（）；
content.commit（api，null）.setResultCallback（new-ResultCallback（））{
@凌驾
公共void onResult（状态）{
mToast（“上传成功！”）；
}
});
}catch（filenotfounde异常）{
e、 printStackTrace（）；
}捕获（IOE异常）{
public static void doDriveBackup () {
    Drive.DriveApi.newDriveContents(api).setResultCallback(backupContentsCallback);
}

public static void restoreDriveBackup() {
    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) {

            /*for(int i = 0 ;i < metadataBufferResult.getMetadataBuffer().getCount() ;i++) {
                debug("got index "+i);
                debug("filesize in cloud "+ metadataBufferResult.getMetadataBuffer().get(i).getFileSize());
                debug("driveId(1): "+ metadataBufferResult.getMetadataBuffer().get(i).getDriveId());
            }*/


            int count = metadataBufferResult.getMetadataBuffer().getCount() - 1;
            //debug("Count: " + count);
            driveId = metadataBufferResult.getMetadataBuffer().get(0).getDriveId();
            //debug("driveId: " + driveId);
            debug("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) {
                    //mToast("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()) {
                    mToast("Unable to open file, try again.");
                    return;
                }

                utilsM.dbClose();

                db_file = getDbPath();
                String path = db_file.getPath();

                if ( !db_file.exists())
                    db_file.delete();

                db_file = new File(path);

                DriveContents contents = result.getDriveContents();
                //debug("driveId:(2)" + contents.getDriveId());

                try {
                    FileOutputStream fos = new FileOutputStream(db_file);
                    BufferedOutputStream bos = new BufferedOutputStream(fos);
                    BufferedInputStream in = new BufferedInputStream(contents.getInputStream());

                    byte[] buffer = new byte[1024];
                    int n, cnt = 0;


                    //debug("before read " + in.available());

                    while( ( n = in.read(buffer) ) > 0) {
                        bos.write(buffer, 0, n);
                        cnt += n;
                        debug("buffer: " + buffer[0]);
                        debug("buffer: " + buffer[1]);
                        debug("buffer: " + buffer[2]);
                        debug("buffer: " + buffer[3]);
                        bos.flush();
                    }

                    //debug(" read done: " + cnt);

                    bos.close();

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

                mToast(act.getResources().getString(R.string.restoreComplete));
                DialogFragment_Sync.dismissDialog();

                utilsM.dbOpen();
                mRecyclerView.invalidate();
                mAdapter.notifyDataSetChanged();
                contents.discard(api);

            }
        };






static final private ResultCallback<DriveApi.DriveContentsResult> backupContentsCallback = new ResultCallback<DriveApi.DriveContentsResult>() {

    @Override
    public void onResult(DriveApi.DriveContentsResult result) {
        if (!result.getStatus().isSuccess()) {
            mToast("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(mimeType)
                .setStarred(true).build();
        // create a file on root folder
        Drive.DriveApi.getRootFolder(api)
                .createFile(api, changeSet, result.getDriveContents())
                .setResultCallback(backupFileCallback);
    }
};
static final private ResultCallback<DriveFolder.DriveFileResult> backupFileCallback = new ResultCallback<DriveFolder.DriveFileResult>() {
    @Override
    public void onResult(DriveFolder.DriveFileResult result) {
        if (!result.getStatus().isSuccess()) {
            mToast("Error while trying to create the file, try again.");
            DialogFragment_Sync.dismissDialog();
            return;
        }
        mfile = result.getDriveFile();
        mfile.open(api, DriveFile.MODE_WRITE_ONLY, new DriveFile.DownloadProgressListener() {
            @Override
            public void onProgress(long bytesDownloaded, long bytesExpected) {
                DialogFragment_Sync.setProgressText("Creating backup file... ("+bytesDownloaded+"/"+bytesExpected+")");
            }
        }).setResultCallback(backupContentsOpenedCallback);
    }
};
static final private ResultCallback<DriveApi.DriveContentsResult> backupContentsOpenedCallback = new ResultCallback<DriveApi.DriveContentsResult>() {
    @Override
    public void onResult(DriveApi.DriveContentsResult result) {
        if (!result.getStatus().isSuccess()) {
            DialogFragment_Sync.dismissDialog();
            mToast("Error opening file, try again.");
            return;
        }

        DialogFragment_Sync.setProgressText("Backing up..");

        DriveContents contents = result.getDriveContents();
        BufferedOutputStream bos = new BufferedOutputStream(contents.getOutputStream());
        byte[] buffer = new byte[1024];
        int n;

        try {
            FileInputStream is = new FileInputStream(getDbPath());
            BufferedInputStream bis = new BufferedInputStream(is);

            while( ( n = bis.read(buffer) ) > 0 ) {
                bos.write(buffer, 0, n);
                DialogFragment_Sync.setProgressText("Backing up...");
            }
            bos.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) {
                DialogFragment_Sync.setProgressText("Backup completed!");
                mToast(act.getResources().getString(R.string.backupComplete));
                DialogFragment_Sync.dismissDialog();
            }
        });
    }
};