Question

我在更新Android应用程序中的现有缓存文件时遇到了麻烦。

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

我在Synced Dropbox文件夹中放置了具有相同名称的不同文件，在下载后我得到了旧版本的文件。
有什么办法可以更新我现有的缓存文件或清除Dropbox缓存（在我的应用程序中）非常感谢任何帮助，谢谢。

Answer 1

以下是Sync API的工作原理：

它会不断同步元数据（存在哪些文件及其修订版），并通过您在文件系统上设置的侦听器通知您。
对于 打开文件 ，它会下载所有可用文件的较新版本，并通过您在文件本身上设置的监听器通知您。

因此，如果您想获取文件的最新版本，则需要打开文件并保持打开，同时等待侦听器通知您文件的较新版本已缓存。然后，您可以致电update以访问该新数据。

编辑：粘贴来自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
}

Answer 2

这是我尝试获取最新文件但正如我在您的问题的评论中所述，似乎我有时必须进行两次同步调用才能获取最新文件。

fileModified和fileSize比较相当粗糙，但似乎可以解决问题。比我迄今为止至少发现的要好。

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

我无法找到适合自己的榜样。但对于我的情况 - 我不需要兑换版本的文件 - 只有最新版本（设备之间的数据同步）。

我用过

mDbFileSystem.setMaxFileCacheSize(0);

全有或全无。但现在是在后台下载的nessasary线程。

Dropbox Sync API Android - 更新缓存文件

3 个答案: