I want to upload my database, i created in my app, with the drive api, to the users drive. I writed now some code and searched in the internet how i upload a database. When i test it now it always say's that the GoogleApi is connected and is uploading the database, still when im not connected to the internet, i wonder how.
Here's my code:
public class Activity_Main extends AppCompatActivity implements GoogleApiClient.ConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener {
private static GoogleApiClient api;
private static final String DATABASE_NAME = utilsDB.DATABASE_NAME;
private static final String GOOGLE_DRIVE_FILE_NAME = db_backup;
private boolean mResolvingError = false;
private DriveFile mfile;
private static final int DIALOG_ERROR_CODE =100;
@Override
protected void onCreate(Bundle savedInstanceState) {
...
api = new GoogleApiClient.Builder(this)
.addApi(Drive.API)
.addScope(Drive.SCOPE_FILE)
.addConnectionCallbacks(this)
.addOnConnectionFailedListener(this)
.build();
...
}
@Override
public void onConnectionFailed(ConnectionResult result) {
mToast(Connection failed...);
if(mResolvingError) {
return;
} else if(result.hasResolution()) {
mResolvingError = true;
try {
result.startResolutionForResult(this, DIALOG_ERROR_CODE);
} catch (IntentSender.SendIntentException e) {
e.printStackTrace();
}
} else {
ErrorDialogFragment fragment = new ErrorDialogFragment();
Bundle args = new Bundle();
args.putInt(error, result.getErrorCode());
fragment.setArguments(args);
fragment.show(getFragmentManager(), errordialog);
}
}
@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
mToast(onActivityResult);
if(requestCode == DIALOG_ERROR_CODE) {
mResolvingError = false;
if(resultCode == RESULT_OK) {
if(!api.isConnecting() && !api.isConnected()) {
api.connect();
}
}
}
}
@Override
public void onConnected(Bundle connectionHint) {
mToast(Connected successfully);
Drive.DriveApi.newDriveContents(api).setResultCallback(contentsCallback);
}
final private ResultCallbackDriveApi.DriveContentsResult contentsCallback = new ResultCallbackDriveApi.DriveContentsResult() {
@Override
public void onResult(DriveApi.DriveContentsResult result) {
if (!result.getStatus().isSuccess()) {
debug(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(fileCallback);
}
};
final private ResultCallbackDriveFolder.DriveFileResult fileCallback = new ResultCallbackDriveFolder.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(contentsOpenedCallback);
}
};
final private ResultCallbackDriveApi.DriveContentsResult contentsOpenedCallback = new ResultCallbackDriveApi.DriveContentsResult() {
@Override
public void onResult(DriveApi.DriveContentsResult result) {
if (!result.getStatus().isSuccess()) {
mToast(Error opening file);
return;
}
try {
mToast(Uploading db...);
FileInputStream is = new FileInputStream(getDbPath());
BufferedInputStream in = new BufferedInputStream(is);
byte[] buffer = new byte[8 1024];
DriveContents content = result.getDriveContents();
BufferedOutputStream out = new BufferedOutputStream(content.getOutputStream());
int n = 0;
while( ( n = in.read(buffer) ) 0 ) {
out.write(buffer, 0, n);
}
in.close();
mToast(Upload successfull!);
api.disconnect();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
};
private File getDbPath() {
return getDatabasePath(DATABASE_NAME);
}
@Override
public void onConnectionSuspended(int cause) {
debug(Connection suspended);
}
public void onDialogDismissed() {
mResolvingError = false;
}
public static class ErrorDialogFragment extends DialogFragment {
public ErrorDialogFragment() {}
public Dialog onCreateDialog(Bundle savedInstanceState) {
int errorCode = this.getArguments().getInt(error);
return GooglePlayServicesUtil.getErrorDialog(errorCode, this.getActivity(), DIALOG_ERROR_CODE);
}
public void onDismiss(DialogInterface dialog) {
dialog.dismiss();
}
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
case R.id.sync
mToast(Connecting to Drive API ...);
api.connect();
return true;
}
}
Being connected means you are connected to the GDAA service in GooPlaySvcs, not to the internet. Please read carefully GDAA docs (see schema there) and you will see that the whole point is, that GDAA tries to shield your app from network on-line / off-line states (as much as possible).
Your local state is synced as soon as there is network connection. Also, even if your wifi is connected, it does not mean your GDAA requests will be satisfied immediately, GDAA will optimize the network traffic based on it's internal logic.
You can easily relinquish these advantages and gain full control by switching to the REST Api, but you will have to handle the on/off-line states, request results, ... by yourself. And probably end using sync adapter anyway. Messy.
Good Luck