Dropbox Sync API Android - Updating Cached Files

Question

I am facing trouble in updating the existing cached file within my Android Application.

for(DbxFileInfo fInfo : fileList)
{
    Log.d(TAG, "File Path = "+fInfo.path.toString());
    String fileName = fInfo.path.getName().trim();

    try
    {
        DbxPath tempFilePath    = new DbxPath(fInfo.path.toString());
        DbxFile tempFile        = mDbFileSystem.open(tempFilePath);

        if(tempFile.getSyncStatus().isCached)
        {
            Log.v(TAG, "File is already cached !");

            if(tempFile.getSyncStatus().isLatest)
            {
                Log.v(TAG, "File's Latest Version is Cached !");
            }
            else
            {
                Log.v(TAG, "File's Latest Version is not Cached !");
            }
        }

        try
        {
            tempFile.getNewerStatus();
        }
        catch(Exception dBException)
        {
            Log.e(TAG, "Error while getting newer Status !");
        }

        InputStream input       = new BufferedInputStream(tempFile.getReadStream());
        OutputStream output     = new FileOutputStream(cntx.getFilesDir() + "/SyncedData/" + fileName);

        byte data[] = new byte[1024];
        int count;

        //total size is in Bytes
        while ((count = input.read(data)) != -1)
        {
            totalBytesDownloaded += count;
            publishProgress((int) (totalBytesDownloaded * 100/totalFileSize));
            output.write(data, 0, count);
        }

        output.flush();
        output.close();
        input.close();
        tempFile.close();
        mDbFileSystem.delete(tempFile.getPath());

        result = true;
    }
    catch(Exception e)
    {
        Log.e(TAG, "Error occured while downloading files !, Error = "+e.toString());
        result = false;
    }
}

I am putting different files with same names on my Synced Dropbox folder and after Downloading them i am getting the older version of files.
Is there any way i can update my existing cached files or Clear the Dropbox Cache (that is within my App) Any help is highly appreciated, thanks.

Answer 1

I can't found working example for me. But for my case - i don't need cashed version of files - only newest (data synchronization between devices).

I used

mDbFileSystem.setMaxFileCacheSize(0);

All or nothing. But now nessasary thread for downloading in background.

Answer 2

Here is my attempt to get the latest file but as I stated in the comment to your question, it seems I sometimes have to do two sync calls in order to get the latest file.

The fileModified and fileSize comparison is rather crude but seems to do the trick. Better than what I have found so far at least.

public DropboxFileDownloader() {
    super("FileDownloader");
}

@Override
protected void onHandleIntent(Intent intent) {

    String turiosHome = intent.getStringExtra(Constants.EXTRA_HOME);
    String fileName = intent.getStringExtra(Constants.EXTRA_FILENAME);
    String folderPath = intent.getStringExtra(Constants.EXTRA_FOLDERPATH);

    ResultReceiver receiver = intent.getParcelableExtra(Constants.EXTRA_RECEIVER);
    Bundle bundle = new Bundle();


    String fullpath = folderPath + "/" + fileName;

    DbxFile file;
    long fileModified = 0;
    long fileSize = 0;

    try {
        file = dbxFs.open(new DbxPath(fullpath));
        try {
            DbxFileStatus fileStatus = file.getNewerStatus();
            if (fileStatus != null && !fileStatus.isLatest) {
                /*while (file.getNewerStatus().pending == PendingOperation.DOWNLOAD) {
                    Log.d(TAG, "Waiting for " + fileName + " to be downloaded");
                    Thread.sleep(1000);
                }*/
                if (fileStatus.isCached) {
                //Start of Edit
                    try 
                    { 
                        //Running this do while loop until the Latest version of this file is cached.
                        do 
                        { 
                            Log.d(TAG, "Updating the existing file !"); 
                            //Updating the file
                            file.update(); 

                            while (file.getNewerStatus().pending ==PendingOperation.DOWNLOAD) 
                            { 
                                Log.d(TAG, "Waiting for " + fileName+ " to be downloaded"); 
                                Thread.sleep(1000);
                            } 
                        } while (fileStatus.isLatest); 
                    }
                    catch (Exception dBException) 
                    { 
                        Log.e(TAG, "Error while getting newer Status !, Error = "+dBException.toString()); 
                        dBException.printStackTrace();
                    }
                //End of Edit
                }
            }
            fileModified = file.getInfo().modifiedTime.getTime();
            fileSize = file.getInfo().size;

        } catch (DbxException e) {
            Log.e(TAG, e.getMessage(), e);
            bundle.putString(Constants.EXTRA_MESSAGE, e.getMessage());
            receiver.send(DropboxFileDownloaderResultReceiver.RESULTCODE_ERROR, bundle);
            return;
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    } catch (InvalidPathException e1) {
        Log.e(TAG, e1.getMessage(), e1);
        bundle.putString(Constants.EXTRA_MESSAGE, e1.getMessage());
        receiver.send(DropboxFileDownloaderResultReceiver.RESULTCODE_ERROR, bundle);
        return;
    } catch (DbxException e1) {
        Log.e(TAG, e1.getMessage(), e1);
        bundle.putString(Constants.EXTRA_MESSAGE, e1.getMessage());
        receiver.send(DropboxFileDownloaderResultReceiver.RESULTCODE_ERROR, bundle);
        return;
    }
    File stored_dir = new File(turiosHome + "/" + folderPath);
    if (!stored_dir.exists()) {
        stored_dir.mkdirs();
    }

    File stored_file = new File(turiosHome + "/" + folderPath,
            fileName);

    // File stored_file = getFileStreamPath(fileName);
    long local_modified = stored_file.lastModified();
    long local_size = stored_file.length();

    boolean should_sync = (fileModified > local_modified)
            || fileSize != local_size;// && Math.abs(fileModified -
                                        // local_modified) >
                                        // TimeUnit.MILLISECONDS.convert(1,
                                        // TimeUnit.MINUTES);
    boolean fileexists = stored_file.exists();
    if (should_sync || !fileexists) {

        InputStream inputStream = null;
        FileOutputStream out = null;
        try {
            // read this file into InputStream
            inputStream = file.getReadStream();

            out = new FileOutputStream(stored_file);
            int read = 0;
            byte[] bytes = new byte[1024];

            int bytes_counter = 0;
            while ((read = inputStream.read(bytes)) != -1) {
                out.write(bytes, 0, read);
                bytes_counter++;
            }

            Log.d(TAG, "Wrote: " + file.getPath().getName() + " "
                    + bytes_counter + " kb");

            if (!fileexists) {
                bundle.putString(Constants.EXTRA_FILEPATH, fullpath);
                receiver.send(DropboxFileDownloaderResultReceiver.RESULTCODE_CREATED, bundle);
            } else {
                bundle.putString(Constants.EXTRA_FILEPATH, fullpath);
                receiver.send(DropboxFileDownloaderResultReceiver.RESULTCODE_UPDATED, bundle);
            }

        } catch (IOException e) {
            Log.e(TAG, e.getMessage(), e);
            bundle.putString(Constants.EXTRA_MESSAGE, e.getMessage());
            receiver.send(DropboxFileDownloaderResultReceiver.RESULTCODE_ERROR, bundle);
        } finally {
            try {
                if (inputStream != null) {
                    inputStream.close();
                }
                if (out != null) {
                    out.flush();
                    out.close();
                }

            } catch (IOException e) {
                Log.e(TAG, e.getMessage(), e);
                bundle.putString(Constants.EXTRA_MESSAGE, e.getMessage());
                receiver.send(DropboxFileDownloaderResultReceiver.RESULTCODE_ERROR, bundle);
            }

        }
    } 
    else {
        bundle.putString(Constants.EXTRA_FILEPATH, fullpath);
        receiver.send(DropboxFileDownloaderResultReceiver.RESULTCODE_UPTODATE, bundle);
    }

    file.close();
}
}

Answer 3

Here's how the Sync API works:

• It constantly syncs metadata (what files exist and their revisions) and notifies you via listeners you set up on the file system.
• For open files, it downloads any newer version of the file available and notifies you via the listener you set up on the file itself.

So if you want to get the latest version of a file, you need to open the file and hold it open while waiting for the listener to notify you that the newer version of the file is cached. Then you can call update to get access to that new data.

EDIT: Pasting code from https://www.dropbox.com/developers/sync/start/android#listeners:

DbxFileStatus status = testFile.getSyncStatus();
if (!status.isCached) {
    testFile.addListener(new DbxFile.Listener() {
        @Override
        public void onFileChange(DbxFile file) {
            // Check testFile.getSyncStatus() and read if it's ready
        }
    });
    // Check if testFile.getSyncStatus() is ready already to ensure nothing
    // was missed while adding the listener
}