I have 3 activities in my Android app. The first one opens an ssh connection and on my raspberry pi it does different kind of things (running python scripts, uploading stuff to dropbox etc). This process generally takes 15-20 seconds and when it is ready, the second activity comes up where i click a button that downloads the files, and then, on the third activity i can see the files that my rpi made.
I want to make the the last two activity into one, so the user does not have to click anything to download his or her file. Which is the easiest way? Can I solve this with delays or threads or only the asynctask remains?
The file gets downloaded earlier in the same activity as this placePic function and then I call it:
EDIT:
public class dropboxDownloader extends AppCompatActivity implements View.OnClickListener {
String apta;
#Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_pic_show);
StrictMode.ThreadPolicy policy = new StrictMode.ThreadPolicy.Builder().permitAll().build();
StrictMode.setThreadPolicy(policy);
if (shouldAskPermissions()) {
askPermissions();
}
AndroidAuthSession session = null;
try {
session = buildSession();
} catch (DropboxException e) {
e.printStackTrace();
}
dropboxAPI = new DropboxAPI<>(session);
String[] fnames = null;
DropboxAPI.Entry dirent = null;
try {
dirent = dropboxAPI.metadata("/", 1000, null, true, null);
} catch (DropboxException e) {
e.printStackTrace();
}
ArrayList<DropboxAPI.Entry> files = new ArrayList<DropboxAPI.Entry>();
ArrayList<String> dir = new ArrayList<String>();
int i = 0;
for (DropboxAPI.Entry ent : dirent.contents) {
files.add(ent);// Add it to the list of thumbs we can choose from
//dir = new ArrayList<String>();
dir.add(files.get(i++).path);
}
apta = "something";
Dir.mkdirs();
final String DropboxDownloadPathTo = path + apta.substring(0, 30);
final String DropboxDownloadPathFrom = apta;
Toast.makeText(getApplicationContext(), "Download file ...", Toast.LENGTH_SHORT)
.show();
File file = new File(DropboxDownloadPathTo + DropboxDownloadPathFrom
.substring(DropboxDownloadPathFrom.lastIndexOf('.')));
if (file.exists()) file.delete();
try {
FileOutputStream outputStream = new FileOutputStream(file);
dropboxDownloader.dropboxAPI.getFile(DropboxDownloadPathFrom, null,
outputStream, null);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (DropboxException e) {
Toast.makeText(this, "ez a hiba: " + e, Toast.LENGTH_SHORT).show();
}
placePic();
}
public void placePic() {
backToMenu = (Button) findViewById(R.id.button6);
backToMenu.setOnClickListener(this);
goToMyPics = (Button) findViewById(R.id.button5);
goToMyPics.setOnClickListener(this);
String this_pic = Environment.getExternalStorageDirectory()
.getAbsolutePath() + "/aha" + apta;
Toast.makeText(this, "this_pic: " + this_pic, Toast.LENGTH_LONG).show();
File f = new File(this_pic);
if (f.exists() && !f.isDirectory()) {
Toast.makeText(this, "delay begins", Toast.LENGTH_SHORT).show();
final Handler handler = new Handler();
handler.postDelayed(new Runnable() {
#Override
public void run() {
Toast.makeText(dropboxDownloader.this, "delayed?", Toast
.LENGTH_SHORT).show();
if (apta.startsWith("/pi_pic_lc")) {
String dedo = Environment.getExternalStorageDirectory().getAbsolutePath() +
"/aha/" +
apta;
Toast.makeText(dropboxDownloader.this, "open this: " + dedo, Toast
.LENGTH_SHORT).show();
try {
ali.setImageURI(Uri.parse(dedo));
} catch (Exception e) {
Toast.makeText(dropboxDownloader.this, "error: " + e, Toast.LENGTH_SHORT)
.show();
}
} else {
String kutya = Environment.getExternalStorageDirectory().getAbsolutePath() +
"/aha/"
+ apta;
Toast.makeText(dropboxDownloader.this, "open this: " + kutya, Toast
.LENGTH_SHORT).show();
try {
ali.setImageURI(Uri.parse(kutya));
PhotoViewAttacher pv = new PhotoViewAttacher(ali);
} catch (Exception e) {
Toast.makeText(dropboxDownloader.this, "error: " + e, Toast.LENGTH_SHORT)
.show();
}
}
}
}, 5000);
} else {
Toast.makeText(this, "cant get you the file", Toast.LENGTH_SHORT).show();
}
}
}
Thanks in advance!
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
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();
}
}
}
My answer assumes that you have a keystore file to sign your app with. If you don't, this link shows you how.
The next thing you need to do is to download the Android and Google play Services SDKs and get an Android certificate, as described here
Now your app should be able to access the Google Drive APIs.
In your activity, create these variables
/**
* Handle access to Drive resources/files.
*/
DriveResourceClient mDriveResourceClient;
/**
* Base folder. This is where the backup will be created
*/
DriveFolder baseFolder;
/**
* Request code for google sign-in, to be used for result of Drive sign-in
* Can be any suitable value
*/
protected static final int REQUEST_CODE_SIGN_IN = 0;
/**
* String variables to hold file names, file paths etc.
*/
static final String BACK_UP = <NAME OF BACKUP FILE CREATED ON DRIVE> ;
static final String dbPath = <PATH TO YOUR DATABASE>;
static final String DATABASE_NAME = <NAME OF YOUR DATABASE>;
/*
* This text view is used to show the output from various operations
*/
private TextView tvDriveResult;
When the user starts the backup process call the function singIn()
/**
* Starts the sign-in process and initializes the Drive client.
*/
private void singIn() {
Set<Scope> requiredScopes = new HashSet<>(2);
requiredScopes.add(Drive.SCOPE_FILE);
GoogleSignInAccount signInAccount = GoogleSignIn.getLastSignedInAccount(this);
if (signInAccount != null && signInAccount.getGrantedScopes().containsAll(requiredScopes)) {
initializeDriveClient(signInAccount);
} else {
GoogleSignInOptions signInOptions =
new GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_SIGN_IN)
.requestScopes(Drive.SCOPE_FILE)
.build();
GoogleSignInClient googleSignInClient = GoogleSignIn.getClient(this, signInOptions);
startActivityForResult(googleSignInClient.getSignInIntent(), REQUEST_CODE_SIGN_IN);
}
}
The singIn() function will handle a user sign - in by starting Google Sign in Client. You will need to handle the result of this client. Use the following code.
/**
* Handles resolution callbacks.
*/
#Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
super.onActivityResult(requestCode, resultCode, data);
switch (requestCode) {
case REQUEST_CODE_SIGN_IN:
if (resultCode != RESULT_OK) {
/* Sign-in may fail or be cancelled by the user. For this sample, sign-in is
* required and is fatal. For apps where sign-in is optional, handle appropriately
*/
Log.e(TAG, "Sign-in failed.");
return;
}
Task<GoogleSignInAccount> getAccountTask =
GoogleSignIn.getSignedInAccountFromIntent(data);
if (getAccountTask.isSuccessful()) {
initializeDriveClient(getAccountTask.getResult());
} else {
Log.e(TAG, "Sign-in failed.");
tvDriveResult.append("Sign-in failed\n");
}
break;
}
super.onActivityResult(requestCode, resultCode, data);
}
After sign-in has been successfully completed, the drive client is initialised above by calling the initializeDriveClient(GoogleSignInAccount signInAccount) function.
/**
* Continues the sign-in process, initializing the Drive clients with the current
* user's account.
*/
private void initializeDriveClient(GoogleSignInAccount signInAccount) {
mDriveClient = Drive.getDriveClient(getApplicationContext(), signInAccount);
mDriveResourceClient = Drive.getDriveResourceClient(getApplicationContext(), signInAccount);
onDriveClientReady();
}
After the drive client is set up, onDriveClientReady() is called. This function proceeds to create / restore your back-up. The functionality here is very simple a. Get the base folder of the user's Google Drive account. b. Check if a back-up file exists. c. If yes, copy that backup to the local database file (over write complete file). d. If no, copy the local database file to the user's Google Drive base folder. You can add some finesse to this logic if you wish. My code is to help you understand the process.
/**
* Called after the user has signed in and the Drive client has been initialized.
*/
private void onDriveClientReady(){
/* Initialise the root folder. */
/* Since the tasks are executed in a separate execution threads, the remaining tasks are called from within each other */
getRootFolder();
}
The getRootFolder() function proceeds as follows
private void getRootFolder() {
/* Get the app folder */
Task<DriveFolder> appFolderTask = mDriveResourceClient.getRootFolder();
appFolderTask
.addOnSuccessListener(this, new OnSuccessListener<DriveFolder>() {
#Override
public void onSuccess(DriveFolder driveFolder) {
tvDriveResult.append("Root folder found\n");
baseFolder = driveFolder;
/* Base folder is found, now check if backup file exists */
checkForBackUp();
/* Use this to delete files. Remember to comment out the line able it */
/* listFilesInBaseFolder(); */
}
})
.addOnFailureListener(this, new OnFailureListener() {
#Override
public void onFailure(#NonNull Exception e) {
tvDriveResult.append("Root folder not found, error: " + e.toString() + "\n");
}
});
}
There is also a function in here called listFilesInBaseFolder() to delete (permanently delete not simply trash) all files you created. It has been commented out in. Use it in case you want to delete files you created, use with caution. As far as I can tell it works only on files that were created by your application.
Check for backup.
private void checkForBackUp() {
/* Build a query */
Query query = new Query.Builder()
.addFilter(Filters.eq(SearchableField.TITLE, BACK_UP))
.build();
/* Query contents of app folder */
Task<MetadataBuffer> queryTask = mDriveResourceClient.queryChildren(baseFolder, query);
/* Check for result of query */
queryTask
.addOnSuccessListener(this, new OnSuccessListener<MetadataBuffer>() {
#Override
public void onSuccess(MetadataBuffer metadataBuffer) {
/* if count is 0, the file doesn't exist */
if (metadataBuffer.getCount() == 0){
tvDriveResult.append("File " + BACK_UP + " not found\n");
/* Make file backup */
backUpDatabase();
} else {
tvDriveResult.append(metadataBuffer.getCount() + " Instances of file " + BACK_UP + " found\n");
Metadata metadata = metadataBuffer.get(0);
restoreBackUp(metadata.getDriveId().asDriveFile());
}
}
})
.addOnFailureListener(this, new OnFailureListener() {
#Override
public void onFailure(#NonNull Exception e) {
tvDriveResult.append("Could not search for file, error: " + e.toString() + "\n");
}
});
}
restoreBackUp(DriveFile driveFile) will over write the local database file with the file found on Goole Drive.
private void restoreBackUp(DriveFile driveFile) {
tvDriveResult.append("Restoring from backup\n");
/* Get the path of the local backup */
File dbFileOld = new File(dbPath + DATABASE_NAME);
/* Check of dbFileExists on device, delete if it does because it needs to be completely over written */
if (dbFileOld.exists()){
dbFileOld.delete();
}
File dbFileNew = new File(dbPath + DATABASE_NAME);
/* File input stream from database to read from */
final FileOutputStream fileOutputStream;
try {
fileOutputStream = new FileOutputStream(dbFileNew);
} catch (FileNotFoundException e) {
tvDriveResult.append("Could not get input stream from local file\n");
return;
}
/* Task to open file */
Task<DriveContents> openFileTask =
mDriveResourceClient.openFile(driveFile, DriveFile.MODE_READ_ONLY);
/* Continue with task */
openFileTask.continueWithTask(new Continuation<DriveContents, Task<Void>>(){
#Override
public Task<Void> then(#NonNull Task<DriveContents> task) throws Exception {
DriveContents backupContents = task.getResult();
InputStream inputStream = backupContents.getInputStream();
tvDriveResult.append("Attempting to restore from database\n");
byte[] buffer = new byte[4096];
int c;
while ((c = inputStream.read(buffer, 0, buffer.length)) > 0){
fileOutputStream.write(buffer, 0, c);
}
fileOutputStream.flush();
fileOutputStream.close();
fileOutputStream.flush();
fileOutputStream.close();
tvDriveResult.append("Database restored\n");
/* Return statement needed to avoid task failure */
Task<Void> discardTask = mDriveResourceClient.discardContents(backupContents);
return discardTask;
}
})
.addOnFailureListener(new OnFailureListener() {
#Override
public void onFailure(#NonNull Exception e) {
tvDriveResult.append("Could not read file contents\n");
}
});
}
And lastly, backUpDatabase() creates a backup of your local database.
private void backUpDatabase() {
tvDriveResult.append("Creating Drive back-up");
/* get the path of the local backup */
File dbFile = new File(dbPath + DATABASE_NAME);
/* Check of dbFileExists on device */
if (! dbFile.exists()){
tvDriveResult.append("Local database not found?!\n");
return;
}
/* File input stream from database to read from */
final FileInputStream fileInputStream;
try {
fileInputStream = new FileInputStream(dbFile);
} catch (FileNotFoundException e) {
tvDriveResult.append("Could not get input stream from local file\n");
return;
}
/* Task to make file */
final Task<DriveContents> createContentsTask = mDriveResourceClient.createContents();
tvDriveResult.append("Creating a back-up of the Database File\n");
Tasks.whenAll(createContentsTask).continueWithTask(new Continuation<Void, Task<DriveFile>>() {
#Override
public Task<DriveFile> then(#NonNull Task<Void> task) throws Exception {
/* Retrieved the drive contents returned by the Task */
DriveContents contents = createContentsTask.getResult();
/* Output stream where data will be written */
OutputStream outputStream = contents.getOutputStream();
/* File output stream */
tvDriveResult.append("Attempting to write\n");
byte[] buffer = new byte[4096];
int c;
while ((c = fileInputStream.read(buffer, 0, buffer.length)) > 0){
outputStream.write(buffer, 0, c);
}
outputStream.flush();
outputStream.close();
fileInputStream.close();
tvDriveResult.append("Database written\n");
/* Save the file, using MetadataChangeSet */
MetadataChangeSet changeSet = new MetadataChangeSet.Builder()
.setTitle(BACK_UP)
.setMimeType("application/x-sqlite3")
.setStarred(false)
.build();
return mDriveResourceClient.createFile(baseFolder, changeSet, contents);
}
})
/* Task successful */
.addOnSuccessListener(new OnSuccessListener<DriveFile>() {
#Override
public void onSuccess(DriveFile driveFile) {
tvDriveResult.append("Back up file created\n");
}
})
.addOnFailureListener(new OnFailureListener() {
#Override
public void onFailure(#NonNull Exception e) {
tvDriveResult.append("Could not create back up file\n");
}
});
}
And that is it! This should get you started with basic operations. I recommend going through Google's Developer Guide for a deeper dive.
I want the app can achieve follow functions
1.put file name into ediTtext
2.press a start button,
if the file exists, write into the file, if not, create the file
3.press stop button,
the process will be stopped and the content of editText will return to the file name.
I have finished the save file part, but don't know how to check existence :P, hope can get some code for reference!
Thanks!
Here is the code for saving file:
////////////////////////////////////
private String TAG = "MyActivity";
private WifiManager wifiManager;
List<ScanResult> list;
private Runnable runnable;
private Handler handler;
#Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_wifi_list);
handler=new Handler();
runnable=new Runnable() {
#Override
public void run() {
init();
handler.postDelayed(this, 3000);
}
};
handler.post(runnable);
}
private void init() {
wifiManager = (WifiManager) getSystemService(Context.WIFI_SERVICE);
list = wifiManager.getScanResults();
ListView listView = (ListView) findViewById(R.id.listView);
String wifiInfo = "";
if (list == null) {
Toast.makeText(this, "wifi is closed！", Toast.LENGTH_LONG).show();
}else {
for (int i = 0; i<list.size();i++){
ScanResult scanResult = list.get(i);
String bssid = scanResult.BSSID;
String ssid = scanResult.SSID;
int strength = Math.abs(scanResult.level);
wifiInfo = wifiInfo + String.format("%25s,%20s,%5d\n", bssid,ssid,strength);
}
listView.setAdapter(new NewAdapter(this,list));
}
writeToFile(wifiInfo,"WifiList_Info.txt");
Toast toast = Toast.makeText(this, "new record", Toast.LENGTH_SHORT);
toast.setGravity(Gravity.CENTER, 0, 0);
toast.show();
}
private void writeToFile(String data,String fileName){
File file = null;
OutputStream output = null;
byte buffer[] = null;
try{
File path = Environment.getExternalStorageDirectory();
file = new File(path,fileName);
if(!file.exists())
file.createNewFile();
output = new FileOutputStream(file, true);
buffer = data.getBytes();
output.write(buffer);
output.flush();
output.close();
}
catch(Exception e){ e.printStackTrace();
}
}
public void onClick_startEvent(View view) {
EditText editText = (EditText)findViewById(R.id.et1);
editText.setText("writing into the file", TextView.BufferType.NORMAL);
}
}
for checking file existance use :
File tempFile = null;
tempFile = new File(filePath);
if(!tempFile.exists())
//do your work
File myFile = new File(your_file_path);
if(myFile.exists())
{
// file exists
}
else
{
// file doesn't exists, so create a new file here.
}
I want to set on button click events backup my applications data on SD-Card.
This is my code :
shv.setOnClickListener(new OnClickListener() {
#Override
public void onClick(View arg0) {
Toast.makeText(SecondActivity.this, "backup Button press",Toast.LENGTH_LONG).show();
boolean rc = MyDatabaseTools.backup();
System.out.println(rc);
if(rc==true)
{
Toast.makeText(SecondActivity.this, "backup Successfully",Toast.LENGTH_LONG).show();
}
else
{
Toast.makeText(SecondActivity.this, "backup error",Toast.LENGTH_LONG).show();
}
}
});
I proceed like this :
public class MyDatabaseTools {
private String appName = "";
private String packageName = "";
public static boolean backup() {
boolean rc = false;
boolean writeable = isSDCardWriteable();
if (writeable) {
File file = new File(Environment.getDataDirectory() + "/data/<com.example.judgedetail>/databases/ado.db");
File fileBackupDir = new File(Environment.getExternalStorageDirectory(), "ADOBOOK" + "/backup");
if (!fileBackupDir.exists()) {
fileBackupDir.mkdirs();
}
if (file.exists()) {
File fileBackup = new File(fileBackupDir, "ado.db");
try {
fileBackup.createNewFile();
/*Files.copyFile(file, fileBackup);*/ //got error here dis line not work
rc = true;
} catch (IOException ioException) {
//
} catch (Exception exception) {
//
}
}
}
return rc;
}
private static boolean isSDCardWriteable() {
boolean rc = false;
String state = Environment.getExternalStorageState();
if (Environment.MEDIA_MOUNTED.equals(state)) {
rc = true;
}
return rc;
}
public MyDatabaseTools(final Context context, final String appName) {
this.appName = appName;
packageName = context.getPackageName();
}
}
Files.copyFile(file, fileBackup);
This line got error.
How shall I solve this ?
Please help.
Try this:
public void writeToSD() throws IOException {
File f=new File("/data/data/com.YourPackageName/databases/DBName");
FileInputStream fis=null;
FileOutputStream fos=null;
try{
fis=new FileInputStream(f);
fos=new FileOutputStream("/mnt/sdcard/dump.db");
while(true){
int i=fis.read();
if(i!=-1){
fos.write(i);
}
else{
break;
}
}
fos.flush();
}
catch(Exception e){
e.printStackTrace();
}
finally{
try{
fos.close();
fis.close();
}
catch(IOException ioe){
System.out.println(ioe);
}
}
}
I don't know where you copied that code from, but either you or the poster missed something. Files.copyFile() is no existing Android API function, and I guess that's what you describe as the line being not working.
You'll have to copy your file using another method, I'd suggest one like this:
https://stackoverflow.com/a/9293885/1691231
Please check the code below.
I am not able to copy a resource file to external storage in android phone.
Though, i'm able to copy using the code i've commented but I want to know the problem with my original code.
public class ExternalData extends Activity implements OnItemSelectedListener,
OnClickListener {
TextView canRead = null;
TextView canWrite = null;
String state = null;
boolean canR, canW;
EditText userEnteredFileName;
Button bConfirm, bSaveAs;
Spinner spinner = null;
String[] stuff = { "Music", "Pictures", "Downloads" };
File path = null;
File file = null;
#Override
protected void onCreate(Bundle savedInstanceState) {
// TODO Auto-generated method stub
super.onCreate(savedInstanceState);
setContentView(R.layout.externaldata);
canRead = (TextView) findViewById(R.id.tvCanRead);
canWrite = (TextView) findViewById(R.id.tvCanWrite);
userEnteredFileName = (EditText) findViewById(R.id.etUserEnteredFileName);
bConfirm = (Button) findViewById(R.id.bConfirm);
bSaveAs = (Button) findViewById(R.id.bSaveAs);
bConfirm.setOnClickListener(this);
bSaveAs.setOnClickListener(this);
ArrayAdapter<String> adapter = new ArrayAdapter<String>(this,
android.R.layout.simple_spinner_item, stuff);
spinner = (Spinner) findViewById(R.id.spinner1);
spinner.setAdapter(adapter);
spinner.setOnItemSelectedListener(this);
}
#Override
public void onItemSelected(AdapterView<?> arg0, View arg1, int arg2,
long arg3) {
int position = spinner.getSelectedItemPosition();
switch (position) {
case 0:
path = Environment
.getExternalStoragePublicDirectory(Environment.DIRECTORY_MUSIC);
break;
case 1:
path = Environment
.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES);
break;
case 2:
path = Environment
.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS);
break;
}
}
public void checkState() {
state = Environment.getExternalStorageState();
if (state.equals(Environment.MEDIA_MOUNTED)) {
canRead.setText("Can Read: true");
canWrite.setText("Can Write: true");
canR = canW = true;
} else if (state.equals(Environment.MEDIA_MOUNTED_READ_ONLY)) {
canRead.setText("Can Read: true");
canWrite.setText("Can Write: false");
canR = true;
canW = false;
} else {
canRead.setText("Can Read: false");
canWrite.setText("Can Write: false");
canR = canW = false;
}
}
#Override
public void onClick(View arg0) {
// TODO Auto-generated method stub
switch (arg0.getId()) {
case R.id.bConfirm:
bSaveAs.setVisibility(View.VISIBLE);
break;
case R.id.bSaveAs:
checkState();
if(canR == canW == true){
file = new File (path, userEnteredFileName.getText().toString() + "/");
try {
if(!file.exists()){
boolean success = file.mkdirs();
if(success){
Toast.makeText(ExternalData.this, "File created", Toast.LENGTH_LONG).show();
}else{
Toast.makeText(ExternalData.this, "Not able to create file", Toast.LENGTH_LONG).show();
}
}
InputStream fis = getResources().openRawResource(R.drawable.darthvader);
/* this works....but wats wrong with the original code
file = new File(file, "darthVader.png");
if(!file.exists()){
file.createNewFile();
}
*/
FileOutputStream fos = new FileOutputStream(file);
byte[] data = new byte[fis.available()];
fis.read(data);
fos.write(data);
fis.close();
fos.close();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
Toast.makeText(ExternalData.this, "FilNOT", Toast.LENGTH_LONG).show();
} catch (IOException e) {
// TODO Auto-generated catch block
Toast.makeText(ExternalData.this, "IO", Toast.LENGTH_LONG).show();
e.printStackTrace();
}
}
break;
}
}
#Override
public void onNothingSelected(AdapterView<?> arg0) {
// TODO Auto-generated method stub
}
}
Did you request the permission in your manifest?
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
see this example for How to write file in sdcard (external storage)
InputStream input;
try {
URL url = new URL (strURL);
input = url.openStream();
byte[] buffer = new byte[1500];
OutputStream output = new FileOutputStream ("/sdcard/"+pos+".png");
int bytesRead = 0;
while ((bytesRead = input.read(buffer, 0, buffer.length)) >= 0)
{
output.write(buffer, 0, bytesRead);
}
finally
{
output.close();
buffer=null;
}
don't forget to give permisson in manifeast file
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />