将sqlite数据库存储到谷歌驱动器

Question

我已经尝试了很多例子，并没有找到任何好的解决方案。

我想存储我的应用程序的数据以存储在sqlite数据库中，然后将其与安装该应用程序的用户的谷歌驱动器帐户同步。

还有一个按钮，它将显示来自谷歌驱动器的数据，用户可以编辑和更新数据，以便更新后的数据存储在谷歌驱动器中。 我是Android新手，请帮助我。

我也应用了下面的例子，但没有成功。 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

由于

Answer 1

首先使用下面线

Driver_utils.create_backup（SettingActivity.this）在SD卡分贝备份;

**添加下面的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(); 
       } 
      } 
     }); 

**而对于恢复使用此**

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

**拨打静态Driver_utils类**

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)); 
    } 
} 

，你需要解压缩程序文件只是创建和复制此

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