private void populateDirectoryList() {
setContentView(R.layout.uploader_layout);
String full_path = "";
for (String a : mParents) full_path += a + "/";
Log_OC.d(TAG, "Populating view with content of : " + full_path);
mFile = mStorageManager.getFileByPath(full_path);
if (mFile != null) {
Vector<OCFile> files = mStorageManager.getFolderContent(mFile);
List<HashMap<String, Object>> data = new LinkedList<HashMap<String, Object>>();
for (OCFile f : files) {
HashMap<String, Object> h = new HashMap<String, Object>();
if (f.isFolder()) {
h.put("dirname", f.getFileName());
data.add(h);
}
}
SimpleAdapter sa =
new SimpleAdapter(
this,
data,
R.layout.uploader_list_item_layout,
new String[] {"dirname"},
new int[] {R.id.textView1});
setListAdapter(sa);
Button btn = (Button) findViewById(R.id.uploader_choose_folder);
btn.setOnClickListener(this);
getListView().setOnItemClickListener(this);
}
}
/** Save new directory in local database */
public void saveFolderInDB() {
OCFile newDir = new OCFile(mRemotePath);
newDir.setMimetype("DIR");
long parentId =
mStorageManager.getFileByPath(FileStorageUtils.getParentPath(mRemotePath)).getFileId();
newDir.setParentId(parentId);
newDir.setModificationTimestamp(System.currentTimeMillis());
mStorageManager.saveFile(newDir);
Log_OC.d(TAG, "Create directory " + mRemotePath + " in Database");
}
/**
* Performs the rename operation.
*
* @param client Client object to communicate with the remote ownCloud server.
*/
@Override
protected RemoteOperationResult run(OwnCloudClient client) {
RemoteOperationResult result = null;
// check if the new name is valid in the local file system
try {
if (!isValidNewName()) {
return new RemoteOperationResult(ResultCode.INVALID_LOCAL_FILE_NAME);
}
String parent = (new File(mFile.getRemotePath())).getParent();
parent = (parent.endsWith(OCFile.PATH_SEPARATOR)) ? parent : parent + OCFile.PATH_SEPARATOR;
mNewRemotePath = parent + mNewName;
if (mFile.isFolder()) {
mNewRemotePath += OCFile.PATH_SEPARATOR;
}
// ckeck local overwrite
if (mStorageManager.getFileByPath(mNewRemotePath) != null) {
return new RemoteOperationResult(ResultCode.INVALID_OVERWRITE);
}
RenameRemoteFileOperation operation =
new RenameRemoteFileOperation(
mFile.getFileName(), mFile.getRemotePath(), mNewName, mFile.isFolder());
result = operation.execute(client);
if (result.isSuccess()) {
if (mFile.isFolder()) {
saveLocalDirectory();
} else {
saveLocalFile();
}
}
} catch (IOException e) {
Log_OC.e(
TAG,
"Rename "
+ mFile.getRemotePath()
+ " to "
+ ((mNewRemotePath == null) ? mNewName : mNewRemotePath)
+ ": "
+ ((result != null) ? result.getLogMessage() : ""),
e);
}
return result;
}
@Override
public void onReceive(Context context, Intent intent) {
String accountName = intent.getStringExtra(FileUploader.ACCOUNT_NAME);
if (!isEmpty() && accountName.equals(mAccount.name)) {
boolean uploadWasFine = intent.getBooleanExtra(FileUploader.EXTRA_UPLOAD_RESULT, false);
String uploadRemotePath = intent.getStringExtra(FileUploader.EXTRA_REMOTE_PATH);
if (mFile.getRemotePath().equals(uploadRemotePath)) {
if (uploadWasFine) {
FileDataStorageManager fdsm =
new FileDataStorageManager(
mAccount, getActivity().getApplicationContext().getContentResolver());
mFile = fdsm.getFileByPath(mFile.getRemotePath());
}
updateFileDetails(); // it updates the buttons; must be called although !uploadWasFine;
// interrupted uploads still leave an incomplete file in the server
}
}
}
private OCFile createLocalFolder(String remotePath) {
String parentPath = new File(remotePath).getParent();
parentPath =
parentPath.endsWith(OCFile.PATH_SEPARATOR)
? parentPath
: parentPath + OCFile.PATH_SEPARATOR;
OCFile parent = mStorageManager.getFileByPath(parentPath);
if (parent == null) {
parent = createLocalFolder(parentPath);
}
if (parent != null) {
OCFile createdFolder = new OCFile(remotePath);
createdFolder.setMimetype("DIR");
createdFolder.setParentId(parent.getFileId());
mStorageManager.saveFile(createdFolder);
return createdFolder;
}
return null;
}
/**
* Updates the view with all relevant details about that file.
*
* <p>TODO Remove parameter when the transferring state of files is kept in database.
*
* <p>TODO REFACTORING! this method called 5 times before every time the fragment is shown!
*
* @param transferring Flag signaling if the file should be considered as downloading or
* uploading, although {@link FileDownloaderBinder#isDownloading(Account, OCFile)} and {@link
* FileUploaderBinder#isUploading(Account, OCFile)} return false.
* @param refresh If 'true', try to refresh the hold file from the database
*/
public void updateFileDetails(boolean transferring, boolean refresh) {
if (readyToShow()) {
if (refresh && mStorageManager != null) {
mFile = mStorageManager.getFileByPath(mFile.getRemotePath());
}
// set file details
setFilename(mFile.getFileName());
setFiletype(mFile.getMimetype());
setFilesize(mFile.getFileLength());
if (ocVersionSupportsTimeCreated()) {
setTimeCreated(mFile.getCreationTimestamp());
}
setTimeModified(mFile.getModificationTimestamp());
CheckBox cb = (CheckBox) getView().findViewById(R.id.fdKeepInSync);
cb.setChecked(mFile.keepInSync());
// configure UI for depending upon local state of the file
// if (FileDownloader.isDownloading(mAccount, mFile.getRemotePath()) ||
// FileUploader.isUploading(mAccount, mFile.getRemotePath())) {
FileDownloaderBinder downloaderBinder = mContainerActivity.getFileDownloaderBinder();
FileUploaderBinder uploaderBinder = mContainerActivity.getFileUploaderBinder();
if (transferring
|| (downloaderBinder != null && downloaderBinder.isDownloading(mAccount, mFile))
|| (uploaderBinder != null && uploaderBinder.isUploading(mAccount, mFile))) {
setButtonsForTransferring();
} else if (mFile.isDown()) {
setButtonsForDown();
} else {
// TODO load default preview image; when the local file is removed, the preview remains
// there
setButtonsForRemote();
}
}
getView().invalidate();
}
/**
* Checks the existence of the folder where the current file will be uploaded both in the remote
* server and in the local database.
*
* <p>If the upload is set to enforce the creation of the folder, the method tries to create it
* both remote and locally.
*
* @param pathToGrant Full remote path whose existence will be granted.
* @return An {@link OCFile} instance corresponding to the folder where the file will be uploaded.
*/
private RemoteOperationResult grantFolderExistence(String pathToGrant) {
RemoteOperation operation = new ExistenceCheckRemoteOperation(pathToGrant, this, false);
RemoteOperationResult result = operation.execute(mUploadClient);
if (!result.isSuccess()
&& result.getCode() == ResultCode.FILE_NOT_FOUND
&& mCurrentUpload.isRemoteFolderToBeCreated()) {
operation = new CreateFolderOperation(pathToGrant, true, mStorageManager);
result = operation.execute(mUploadClient);
}
if (result.isSuccess()) {
OCFile parentDir = mStorageManager.getFileByPath(pathToGrant);
if (parentDir == null) {
parentDir = createLocalFolder(pathToGrant);
}
if (parentDir != null) {
result = new RemoteOperationResult(ResultCode.OK);
} else {
result = new RemoteOperationResult(ResultCode.UNKNOWN_ERROR);
}
}
return result;
}
/**
* Core upload method: sends the file(s) to upload
*
* @param uploadKey Key to access the upload to perform, contained in mPendingUploads
*/
public void uploadFile(String uploadKey) {
synchronized (mPendingUploads) {
mCurrentUpload = mPendingUploads.get(uploadKey);
}
if (mCurrentUpload != null) {
notifyUploadStart(mCurrentUpload);
RemoteOperationResult uploadResult = null, grantResult = null;
try {
/// prepare client object to send requests to the ownCloud server
if (mUploadClient == null || !mLastAccount.equals(mCurrentUpload.getAccount())) {
mLastAccount = mCurrentUpload.getAccount();
mStorageManager = new FileDataStorageManager(mLastAccount, getContentResolver());
mUploadClient =
OwnCloudClientFactory.createOwnCloudClient(mLastAccount, getApplicationContext());
}
/// check the existence of the parent folder for the file to upload
String remoteParentPath = new File(mCurrentUpload.getRemotePath()).getParent();
remoteParentPath =
remoteParentPath.endsWith(OCFile.PATH_SEPARATOR)
? remoteParentPath
: remoteParentPath + OCFile.PATH_SEPARATOR;
grantResult = grantFolderExistence(remoteParentPath);
/// perform the upload
if (grantResult.isSuccess()) {
OCFile parent = mStorageManager.getFileByPath(remoteParentPath);
mCurrentUpload.getFile().setParentId(parent.getFileId());
uploadResult = mCurrentUpload.execute(mUploadClient);
if (uploadResult.isSuccess()) {
saveUploadedFile();
}
} else {
uploadResult = grantResult;
}
} catch (AccountsException e) {
Log_OC.e(TAG, "Error while trying to get autorization for " + mLastAccount.name, e);
uploadResult = new RemoteOperationResult(e);
} catch (IOException e) {
Log_OC.e(TAG, "Error while trying to get autorization for " + mLastAccount.name, e);
uploadResult = new RemoteOperationResult(e);
} finally {
synchronized (mPendingUploads) {
mPendingUploads.remove(uploadKey);
Log_OC.i(TAG, "Remove CurrentUploadItem from pending upload Item Map.");
}
if (uploadResult.isException()) {
// enforce the creation of a new client object for next uploads; this grant that a new
// socket will
// be created in the future if the current exception is due to an abrupt lose of network
// connection
mUploadClient = null;
}
}
/// notify result
notifyUploadResult(uploadResult, mCurrentUpload);
sendFinalBroadcast(mCurrentUpload, uploadResult);
}
}
