import java.io.File;
import java.util.AbstractList;
-import java.util.Collections;
-import java.util.HashMap;
import java.util.Iterator;
-import java.util.Map;
import java.util.Vector;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import com.owncloud.android.datamodel.FileDataStorageManager;
import com.owncloud.android.datamodel.OCFile;
import com.owncloud.android.files.InstantUploadBroadcastReceiver;
-import com.owncloud.android.files.services.FileDownloader.FileDownloaderBinder;
import com.owncloud.android.operations.ChunkedUploadFileOperation;
-import com.owncloud.android.operations.DownloadFileOperation;
import com.owncloud.android.operations.RemoteOperationResult;
import com.owncloud.android.operations.UploadFileOperation;
import com.owncloud.android.ui.activity.FileDetailActivity;
import android.os.Message;
import android.os.Process;
import android.util.Log;
+import android.webkit.MimeTypeMap;
import android.widget.RemoteViews;
import com.owncloud.android.R;
private Account mLastAccount = null, mLastAccountWhereInstantFolderWasCreated = null;
private FileDataStorageManager mStorageManager;
- //private AbstractList<Account> mAccounts = new Vector<Account>();
- //private AbstractList<UploadFileOperation> mUploads = new Vector<UploadFileOperation>();
- //private int mCurrentIndexUpload;
private ConcurrentMap<String, UploadFileOperation> mPendingUploads = new ConcurrentHashMap<String, UploadFileOperation>();
private UploadFileOperation mCurrentUpload = null;
private Notification mNotification;
private int mLastPercent;
private RemoteViews mDefaultNotificationContentView;
- /*private long mTotalDataToSend, mSendData;
- private int mTotalFilesToSend, mPreviousPercent;
- private int mSuccessCounter;*/
/**
AbstractList<String> requestedUploads = new Vector<String>();
String uploadKey = null;
UploadFileOperation newUpload = null;
+ OCFile file = null;
+ FileDataStorageManager storageManager = new FileDataStorageManager(account, getContentResolver());
try {
for (int i=0; i < localPaths.length; i++) {
uploadKey = buildRemoteName(account, remotePaths[i]);
+ file = obtainNewOCFileToUpload(remotePaths[i], localPaths[i], ((mimeTypes!=null)?mimeTypes[i]:(String)null), forceOverwrite, storageManager);
if (chunked) {
- newUpload = new ChunkedUploadFileOperation(account, localPaths[i], remotePaths[i], ((mimeTypes!=null)?mimeTypes[i]:(String)null), isInstant, forceOverwrite);
+ newUpload = new ChunkedUploadFileOperation(account, file, isInstant, forceOverwrite);
} else {
- newUpload = new UploadFileOperation(account, localPaths[i], remotePaths[i], (mimeTypes!=null?mimeTypes[i]:(String)null), isInstant, forceOverwrite);
+ newUpload = new UploadFileOperation(account, file, isInstant, forceOverwrite);
}
mPendingUploads.putIfAbsent(uploadKey, newUpload);
newUpload.addDatatransferProgressListener(this);
upload = mPendingUploads.remove(buildRemoteName(account, file));
}
if (upload != null) {
- // TODO upload.cancel();
+ upload.cancel();
}
}
if (mCurrentUpload != null) {
- /// prepare upload statistics
- /*mTotalDataToSend = mSendData = mPreviousPercent = 0;
- Iterator<UploadFileOperation> it = mUploads.iterator();
- while (it.hasNext()) {
- mTotalDataToSend += new File(it.next().getLocalPath()).length();
- }
- mTotalFilesToSend = mUploads.size();
- Log.d(TAG, "Will upload " + mTotalDataToSend + " bytes, with " + mUploads.size() + " files");*/
-
-
notifyUploadStart(mCurrentUpload);
/// perform the upload
RemoteOperationResult uploadResult = null;
- long parentDirId = -1;
try {
- File remote = new File(mCurrentUpload.getRemotePath());
- parentDirId = mStorageManager.getFileByPath(remote.getParent().endsWith("/")?remote.getParent():remote.getParent()+"/").getFileId();
- File local = new File(mCurrentUpload.getLocalPath());
- long size = local.length();
uploadResult = mCurrentUpload.execute(mUploadClient);
if (uploadResult.isSuccess()) {
- saveNewOCFile(mCurrentUpload, mStorageManager, parentDirId, size);
+ saveUploadedFile(mCurrentUpload.getFile(), mStorageManager);
}
} finally {
/// notify result
notifyUploadResult(uploadResult, mCurrentUpload);
- sendFinalBroadcast(mCurrentUpload, uploadResult, parentDirId);
+ sendFinalBroadcast(mCurrentUpload, uploadResult);
}
/**
* Saves a new OC File after a successful upload.
*
- * @param upload Upload operation completed.
+ * @param file OCFile describing the uploaded file
* @param storageManager Interface to the database where the new OCFile has to be stored.
* @param parentDirId Id of the parent OCFile.
- * @param size Size of the file.
*/
- private void saveNewOCFile(UploadFileOperation upload, FileDataStorageManager storageManager, long parentDirId, long size) {
- OCFile newFile = new OCFile(upload.getRemotePath());
- newFile.setMimetype(upload.getMimeType());
- newFile.setFileLength(size);
- newFile.setModificationTimestamp(System.currentTimeMillis());
+ private void saveUploadedFile(OCFile file, FileDataStorageManager storageManager) {
+ file.setModificationTimestamp(System.currentTimeMillis());
+ storageManager.saveFile(file);
+ }
+
+
+ private OCFile obtainNewOCFileToUpload(String remotePath, String localPath, String mimeType, boolean forceOverwrite, FileDataStorageManager storageManager) {
+ OCFile newFile = new OCFile(remotePath);
+ newFile.setStoragePath(localPath);
newFile.setLastSyncDate(0);
- newFile.setStoragePath(upload.getLocalPath());
+ newFile.setKeepInSync(forceOverwrite);
+
+ // size
+ if (localPath != null && localPath.length() > 0) {
+ File localFile = new File(localPath);
+ newFile.setFileLength(localFile.length());
+ } // don't worry about not assigning size, the problems with localPath are checked when the UploadFileOperation instance is created
+
+ // MIME type
+ if (mimeType == null || mimeType.length() <= 0) {
+ try {
+ mimeType = MimeTypeMap.getSingleton()
+ .getMimeTypeFromExtension(
+ remotePath.substring(remotePath.lastIndexOf('.') + 1));
+ } catch (IndexOutOfBoundsException e) {
+ Log.e(TAG, "Trying to find out MIME type of a file without extension: " + remotePath);
+ }
+ }
+ if (mimeType == null) {
+ mimeType = "application/octet-stream";
+ }
+ newFile.setMimetype(mimeType);
+
+ // parent dir
+ String parentPath = new File(remotePath).getParent();
+ parentPath = parentPath.endsWith("/")?parentPath:parentPath+"/" ;
+ long parentDirId = storageManager.getFileByPath(parentPath).getFileId();
newFile.setParentId(parentDirId);
- if (upload.getForceOverwrite())
- newFile.setKeepInSync(true);
- storageManager.saveFile(newFile);
+
+ return newFile;
}
+
/**
* Creates a status notification to show the upload progress
mDefaultNotificationContentView = mNotification.contentView;
mNotification.contentView = new RemoteViews(getApplicationContext().getPackageName(), R.layout.progressbar_layout);
mNotification.contentView.setProgressBar(R.id.status_progress, 100, 0, false);
- mNotification.contentView.setTextViewText(R.id.status_text, String.format(getString(R.string.uploader_upload_in_progress_content), 0, new File(upload.getLocalPath()).getName()));
+ mNotification.contentView.setTextViewText(R.id.status_text, String.format(getString(R.string.uploader_upload_in_progress_content), 0, new File(upload.getStoragePath()).getName()));
mNotification.contentView.setImageViewResource(R.id.status_icon, R.drawable.icon);
/// includes a pending intent in the notification showing the details view of the file
- /* TODO
Intent showDetailsIntent = new Intent(this, FileDetailActivity.class);
showDetailsIntent.putExtra(FileDetailFragment.EXTRA_FILE, upload.getFile());
showDetailsIntent.putExtra(FileDetailFragment.EXTRA_ACCOUNT, upload.getAccount());
showDetailsIntent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
mNotification.contentIntent = PendingIntent.getActivity(getApplicationContext(), 0, showDetailsIntent, PendingIntent.FLAG_UPDATE_CURRENT);
- */
mNotificationManager.notify(R.string.uploader_upload_in_progress_ticker, mNotification);
}
mNotification.contentView = mDefaultNotificationContentView;
/// includes a pending intent in the notification showing the details view of the file
- /*
Intent showDetailsIntent = new Intent(this, FileDetailActivity.class);
showDetailsIntent.putExtra(FileDetailFragment.EXTRA_FILE, upload.getFile());
showDetailsIntent.putExtra(FileDetailFragment.EXTRA_ACCOUNT, upload.getAccount());
showDetailsIntent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
mNotification.contentIntent = PendingIntent.getActivity(getApplicationContext(), 0, showDetailsIntent, PendingIntent.FLAG_UPDATE_CURRENT);
- */
mNotification.setLatestEventInfo( getApplicationContext(),
getString(R.string.uploader_upload_succeeded_ticker),
- String.format(getString(R.string.uploader_upload_succeeded_content_single), (new File(upload.getLocalPath())).getName()),
+ String.format(getString(R.string.uploader_upload_succeeded_content_single), (new File(upload.getStoragePath())).getName()),
mNotification.contentIntent);
mNotificationManager.notify(R.string.uploader_upload_in_progress_ticker, mNotification); // NOT AN ERROR; uploader_upload_in_progress_ticker is the target, not a new notification
finalNotification.contentIntent = PendingIntent.getActivity(getApplicationContext(), 0, new Intent(), PendingIntent.FLAG_UPDATE_CURRENT);
finalNotification.setLatestEventInfo( getApplicationContext(),
getString(R.string.uploader_upload_failed_ticker),
- String.format(getString(R.string.uploader_upload_failed_content_single), (new File(upload.getLocalPath())).getName()),
+ String.format(getString(R.string.uploader_upload_failed_content_single), (new File(upload.getStoragePath())).getName()),
finalNotification.contentIntent);
mNotificationManager.notify(R.string.uploader_upload_failed_ticker, finalNotification);
* @param upload Finished upload operation
* @param uploadResult Result of the upload operation
*/
- private void sendFinalBroadcast(UploadFileOperation upload, RemoteOperationResult uploadResult, long parentDirId) {
+ private void sendFinalBroadcast(UploadFileOperation upload, RemoteOperationResult uploadResult) {
Intent end = new Intent(UPLOAD_FINISH_MESSAGE);
- end.putExtra(EXTRA_REMOTE_PATH, upload.getRemotePath());
- end.putExtra(EXTRA_FILE_PATH, upload.getLocalPath());
+ end.putExtra(EXTRA_REMOTE_PATH, upload.getRemotePath()); // real remote path, after possible automatic renaming
+ end.putExtra(EXTRA_FILE_PATH, upload.getStoragePath());
end.putExtra(ACCOUNT_NAME, upload.getAccount().name);
end.putExtra(EXTRA_UPLOAD_RESULT, uploadResult.isSuccess());
- end.putExtra(EXTRA_PARENT_DIR_ID, parentDirId);
+ end.putExtra(EXTRA_PARENT_DIR_ID, upload.getFile().getParentId());
sendBroadcast(end);
}
import org.apache.commons.httpclient.HttpException;
import org.apache.commons.httpclient.methods.PutMethod;
+import com.owncloud.android.datamodel.OCFile;
+
import android.accounts.Account;
import android.util.Log;
private static final String TAG = ChunkedUploadFileOperation.class.getSimpleName();
public ChunkedUploadFileOperation( Account account,
- String localPath,
- String remotePath,
- String mimeType,
+ OCFile file,
boolean isInstant,
boolean forceOverwrite) {
- super(account, localPath, remotePath, mimeType, isInstant, forceOverwrite);
+ super(account, file, isInstant, forceOverwrite);
}
@Override
protected int uploadFile(WebdavClient client) throws HttpException, IOException {
int status = -1;
- PutMethod put = null;
FileChannel channel = null;
FileLock lock = null;
RandomAccessFile raf = null;
try {
- File file = new File(getLocalPath());
+ File file = new File(getStoragePath());
raf = new RandomAccessFile(file, "rw");
channel = raf.getChannel();
lock = channel.tryLock();
- ChunkFromFileChannelRequestEntity entity = new ChunkFromFileChannelRequestEntity(channel, getMimeType(), CHUNK_SIZE);
+ ChunkFromFileChannelRequestEntity entity = new ChunkFromFileChannelRequestEntity(channel, getMimeType(), CHUNK_SIZE, file);
entity.addOnDatatransferProgressListeners(getDataTransferListeners());
long offset = 0;
String uriPrefix = client.getBaseUri() + WebdavUtils.encodePath(getRemotePath()) + "-chunking-" + Math.abs((new Random()).nextInt(9000)+1000) + "-" ;
long chunkCount = (long) Math.ceil((double)file.length() / CHUNK_SIZE);
for (int chunkIndex = 0; chunkIndex < chunkCount ; chunkIndex++, offset += CHUNK_SIZE) {
- put = new PutMethod(uriPrefix + chunkCount + "-" + chunkIndex);
- put.addRequestHeader(OC_CHUNKED_HEADER, OC_CHUNKED_HEADER);
+ mPutMethod = new PutMethod(uriPrefix + chunkCount + "-" + chunkIndex);
+ mPutMethod.addRequestHeader(OC_CHUNKED_HEADER, OC_CHUNKED_HEADER);
entity.setOffset(offset);
- put.setRequestEntity(entity);
- status = client.executeMethod(put);
- client.exhaustResponse(put.getResponseBodyAsStream());
- Log.d(TAG, "Upload of " + getLocalPath() + " to " + getRemotePath() + ", chunk index " + chunkIndex + ", count " + chunkCount + ", HTTP result status " + status);
+ mPutMethod.setRequestEntity(entity);
+ status = client.executeMethod(mPutMethod);
+ client.exhaustResponse(mPutMethod.getResponseBodyAsStream());
+ Log.d(TAG, "Upload of " + getStoragePath() + " to " + getRemotePath() + ", chunk index " + chunkIndex + ", count " + chunkCount + ", HTTP result status " + status);
if (!isSuccess(status))
break;
}
channel.close();
if (raf != null)
raf.close();
- if (put != null)
- put.releaseConnection(); // let the connection available for other methods
+ if (mPutMethod != null)
+ mPutMethod.releaseConnection(); // let the connection available for other methods
}
return status;
}
private static final String TAG = DownloadFileOperation.class.getCanonicalName();
- private Account mAccount = null;
+ private Account mAccount;
private OCFile mFile;
private Set<OnDatatransferProgressListener> mDataTransferListeners = new HashSet<OnDatatransferProgressListener>();
private final AtomicBoolean mCancellationRequested = new AtomicBoolean(false);
}
public String getMimeType() {
- String mimeType = mFile.getMimetype();
+ String mimeType = mFile.getMimetype(); // TODO fix the mime types in OCFiles FOREVER
if (mimeType == null || mimeType.length() <= 0) {
try {
mimeType = MimeTypeMap.getSingleton()
import java.io.IOException;
import java.util.HashSet;
import java.util.Set;
+import java.util.concurrent.atomic.AtomicBoolean;
import org.apache.commons.httpclient.HttpException;
import org.apache.commons.httpclient.methods.PutMethod;
import org.apache.http.HttpStatus;
+import com.owncloud.android.datamodel.OCFile;
import com.owncloud.android.operations.RemoteOperation;
import com.owncloud.android.operations.RemoteOperationResult;
import eu.alefzero.webdav.WebdavUtils;
import android.accounts.Account;
import android.util.Log;
-import android.webkit.MimeTypeMap;
/**
* Remote operation performing the upload of a file to an ownCloud server
private static final String TAG = UploadFileOperation.class.getCanonicalName();
- private Account mAccount = null;
- private String mLocalPath = null;
+ private Account mAccount;
+ private OCFile mFile;
private String mRemotePath = null;
- private String mMimeType = null;
private boolean mIsInstant = false;
private boolean mForceOverwrite = false;
+ PutMethod mPutMethod = null;
private Set<OnDatatransferProgressListener> mDataTransferListeners = new HashSet<OnDatatransferProgressListener>();
+ private final AtomicBoolean mCancellationRequested = new AtomicBoolean(false);
public UploadFileOperation( Account account,
- String localPath,
- String remotePath,
- String mimeType,
+ OCFile file,
boolean isInstant,
boolean forceOverwrite) {
if (account == null)
- throw new IllegalArgumentException("Illegal null account in UploadFileOperation creation");
- if (localPath == null || localPath.length() <= 0)
- throw new IllegalArgumentException("Illegal null or empty localPath in UploadFileOperation creation");
- if (remotePath == null || remotePath.length() <= 0)
- throw new IllegalArgumentException("Illegal null or empty remotePath in UploadFileOperation creation");
-
- mAccount = account;
- mLocalPath = localPath;
- mRemotePath = remotePath;
- mMimeType = mimeType;
- if (mMimeType == null || mMimeType.length() <= 0) {
- try {
- mMimeType = MimeTypeMap.getSingleton()
- .getMimeTypeFromExtension(
- localPath.substring(localPath.lastIndexOf('.') + 1));
- } catch (IndexOutOfBoundsException e) {
- Log.e(TAG, "Trying to find out MIME type of a file without extension: " + localPath);
- }
- }
- if (mMimeType == null) {
- mMimeType = "application/octet-stream";
+ throw new IllegalArgumentException("Illegal NULL account in UploadFileOperation creation");
+ if (file == null)
+ throw new IllegalArgumentException("Illegal NULL file in UploadFileOperation creation");
+ if (file.getStoragePath() == null || file.getStoragePath().length() <= 0 || !(new File(file.getStoragePath()).exists())) {
+ throw new IllegalArgumentException("Illegal file in UploadFileOperation; storage path invalid or file not found: " + file.getStoragePath());
}
+
+ mAccount = account;
+ mFile = file;
+ mRemotePath = file.getRemotePath();
mIsInstant = isInstant;
mForceOverwrite = forceOverwrite;
}
return mAccount;
}
- public String getLocalPath() {
- return mLocalPath;
+ public OCFile getFile() {
+ return mFile;
+ }
+
+ public String getStoragePath() {
+ return mFile.getStoragePath();
}
public String getRemotePath() {
+ //return mFile.getRemotePath(); // DON'T MAKE THIS ; the remotePath used can be different to mFile.getRemotePath() if mForceOverwrite is 'false'; see run(...)
return mRemotePath;
}
public String getMimeType() {
- return mMimeType;
+ return mFile.getMimetype();
}
public boolean isInstant() {
/// perform the upload
nameCheckPassed = true;
+ synchronized(mCancellationRequested) {
+ if (mCancellationRequested.get()) {
+ throw new OperationCancelledException();
+ } else {
+ mPutMethod = new PutMethod(client.getBaseUri() + WebdavUtils.encodePath(mRemotePath));
+ }
+ }
int status = uploadFile(client);
result = new RemoteOperationResult(isSuccess(status), status);
- Log.i(TAG, "Upload of " + mLocalPath + " to " + mRemotePath + ": " + result.getLogMessage());
-
+ Log.i(TAG, "Upload of " + mFile.getStoragePath() + " to " + mRemotePath + ": " + result.getLogMessage());
+
} catch (Exception e) {
- result = new RemoteOperationResult(e);
- Log.e(TAG, "Upload of " + mLocalPath + " to " + mRemotePath + ": " + result.getLogMessage() + (nameCheckPassed?"":" (while checking file existence in server)"), e);
-
+ // TODO something cleaner
+ if (mCancellationRequested.get()) {
+ result = new RemoteOperationResult(new OperationCancelledException());
+ } else {
+ result = new RemoteOperationResult(e);
+ }
+ Log.e(TAG, "Upload of " + mFile.getStoragePath() + " to " + mRemotePath + ": " + result.getLogMessage() + (nameCheckPassed?"":" (while checking file existence in server)"), result.getException());
}
return result;
}
- protected int uploadFile(WebdavClient client) throws HttpException, IOException {
+ protected int uploadFile(WebdavClient client) throws HttpException, IOException, OperationCancelledException {
int status = -1;
- PutMethod put = new PutMethod(client.getBaseUri() + WebdavUtils.encodePath(mRemotePath));
-
try {
- File f = new File(mLocalPath);
- FileRequestEntity entity = new FileRequestEntity(f, mMimeType);
+ File f = new File(mFile.getStoragePath());
+ FileRequestEntity entity = new FileRequestEntity(f, getMimeType());
entity.addOnDatatransferProgressListeners(mDataTransferListeners);
- put.setRequestEntity(entity);
- status = client.executeMethod(put);
- client.exhaustResponse(put.getResponseBodyAsStream());
+ mPutMethod.setRequestEntity(entity);
+ status = client.executeMethod(mPutMethod);
+ client.exhaustResponse(mPutMethod.getResponseBodyAsStream());
} finally {
- put.releaseConnection(); // let the connection available for other methods
+ mPutMethod.releaseConnection(); // let the connection available for other methods
}
return status;
}
}
+ public void cancel() {
+ synchronized(mCancellationRequested) {
+ mCancellationRequested.set(true);
+ if (mPutMethod != null)
+ mPutMethod.abort();
+ }
+ }
+
}
mCurrentDir = mStorageManager.getFileByPath(mCurrentDir.getRemotePath()); // mCurrentDir == null if it is not in the current account\r
}\r
if (mCurrentFile != null) {\r
- mCurrentFile = mStorageManager.getFileByPath(mCurrentFile.getRemotePath()); // mCurrentFile == null if it is not in the current account\r
+ if (mCurrentFile.fileExists()) {\r
+ mCurrentFile = mStorageManager.getFileByPath(mCurrentFile.getRemotePath()); // mCurrentFile == null if it is not in the current account\r
+ } // else : keep mCurrentFile with the received value; this is currently the case of an upload in progress, when the user presses the status notification in a landscape tablet\r
}\r
\r
/// Default to root if mCurrentDir was not found\r
outState.putParcelable(FileDetailFragment.EXTRA_FILE, mCurrentDir);\r
if (mDualPane) {\r
FileDetailFragment fragment = (FileDetailFragment) getSupportFragmentManager().findFragmentByTag(FileDetailFragment.FTAG);\r
- OCFile file = fragment.getDisplayedFile();\r
- if (file != null) {\r
- outState.putParcelable(FileDetailFragment.EXTRA_FILE, file);\r
+ if (fragment != null) {\r
+ OCFile file = fragment.getDisplayedFile();\r
+ if (file != null) {\r
+ outState.putParcelable(FileDetailFragment.EXTRA_FILE, file);\r
+ }\r
}\r
}\r
Log.d(getClass().toString(), "onSaveInstanceState() end");\r
case R.id.fdDownloadBtn: {\r
//if (FileDownloader.isDownloading(mAccount, mFile.getRemotePath())) {\r
FileDownloaderBinder downloaderBinder = mContainerActivity.getFileDownloaderBinder();\r
+ FileUploaderBinder uploaderBinder = mContainerActivity.getFileUploaderBinder();\r
if (downloaderBinder != null && downloaderBinder.isDownloading(mAccount, mFile)) {\r
downloaderBinder.cancel(mAccount, mFile);\r
if (mFile.isDown()) {\r
} else {\r
setButtonsForRemote();\r
}\r
+\r
+ } else if (uploaderBinder != null && uploaderBinder.isUploading(mAccount, mFile)) {\r
+ uploaderBinder.cancel(mAccount, mFile);\r
+ if (!mFile.fileExists()) {\r
+ // TODO make something better\r
+ if (getActivity() instanceof FileDisplayActivity) {\r
+ // double pane\r
+ FragmentTransaction transaction = getActivity().getSupportFragmentManager().beginTransaction();\r
+ transaction.replace(R.id.file_details_container, new FileDetailFragment(null, null), FTAG); // empty FileDetailFragment\r
+ transaction.commit();\r
+ mContainerActivity.onFileStateChanged();\r
+ } else {\r
+ getActivity().finish();\r
+ }\r
+ \r
+ } else if (mFile.isDown()) {\r
+ setButtonsForDown();\r
+ } else {\r
+ setButtonsForRemote();\r
+ }\r
\r
} else {\r
Intent i = new Intent(getActivity(), FileDownloader.class);\r
((Button) getView().findViewById(R.id.fdOpenBtn)).setEnabled(false);\r
((Button) getView().findViewById(R.id.fdRenameBtn)).setEnabled(false);\r
((Button) getView().findViewById(R.id.fdRemoveBtn)).setEnabled(false);\r
+ getView().findViewById(R.id.fdKeepInSync).setEnabled(false);\r
}\r
}\r
\r
((Button) getView().findViewById(R.id.fdOpenBtn)).setEnabled(true);\r
((Button) getView().findViewById(R.id.fdRenameBtn)).setEnabled(true);\r
((Button) getView().findViewById(R.id.fdRemoveBtn)).setEnabled(true);\r
+ getView().findViewById(R.id.fdKeepInSync).setEnabled(true);\r
}\r
}\r
\r
((Button) getView().findViewById(R.id.fdOpenBtn)).setEnabled(false);\r
((Button) getView().findViewById(R.id.fdRenameBtn)).setEnabled(true);\r
((Button) getView().findViewById(R.id.fdRemoveBtn)).setEnabled(true);\r
+ getView().findViewById(R.id.fdKeepInSync).setEnabled(true);\r
}\r
}\r
\r
package eu.alefzero.webdav;
+import java.io.File;
import java.io.IOException;
import java.io.OutputStream;
import java.nio.ByteBuffer;
//private final File mFile;
private final FileChannel mChannel;
private final String mContentType;
- private final long mSize;
+ private final long mChunkSize;
+ private final File mFile;
private long mOffset;
- Set<OnDatatransferProgressListener> mListeners = new HashSet<OnDatatransferProgressListener>();
+ private long mTransferred;
+ Set<OnDatatransferProgressListener> mDataTransferListeners = new HashSet<OnDatatransferProgressListener>();
private ByteBuffer mBuffer = ByteBuffer.allocate(4096);
- public ChunkFromFileChannelRequestEntity(final FileChannel channel, final String contentType, long size) {
+ public ChunkFromFileChannelRequestEntity(final FileChannel channel, final String contentType, long chunkSize, final File file) {
super();
if (channel == null) {
throw new IllegalArgumentException("File may not be null");
}
- if (size <= 0) {
- throw new IllegalArgumentException("Size must be greater than zero");
+ if (chunkSize <= 0) {
+ throw new IllegalArgumentException("Chunk size must be greater than zero");
}
mChannel = channel;
mContentType = contentType;
- mSize = size;
+ mChunkSize = chunkSize;
+ mFile = file;
mOffset = 0;
+ mTransferred = 0;
}
public void setOffset(long offset) {
public long getContentLength() {
try {
- return Math.min(mSize, mChannel.size() - mChannel.position());
+ return Math.min(mChunkSize, mChannel.size() - mChannel.position());
} catch (IOException e) {
- return mSize;
+ return mChunkSize;
}
}
}
public void addOnDatatransferProgressListener(OnDatatransferProgressListener listener) {
- mListeners.add(listener);
+ mDataTransferListeners.add(listener);
}
public void addOnDatatransferProgressListeners(Collection<OnDatatransferProgressListener> listeners) {
- mListeners.addAll(listeners);
+ mDataTransferListeners.addAll(listeners);
}
public void removeOnDatatransferProgressListener(OnDatatransferProgressListener listener) {
- mListeners.remove(listener);
+ mDataTransferListeners.remove(listener);
}
try {
mChannel.position(mOffset);
- while (mChannel.position() < mOffset + mSize && mChannel.position() < mChannel.size()) {
+ long size = mFile.length();
+ if (size == 0) size = -1;
+ while (mChannel.position() < mOffset + mChunkSize && mChannel.position() < mChannel.size()) {
readCount = mChannel.read(mBuffer);
out.write(mBuffer.array(), 0, readCount);
mBuffer.clear();
- it = mListeners.iterator();
+ mTransferred += readCount;
+ it = mDataTransferListeners.iterator();
while (it.hasNext()) {
- it.next().onTransferProgress(readCount);
+ it.next().onTransferProgress(readCount, mTransferred, size, mFile.getName());
}
}
final File mFile;
final String mContentType;
- Set<OnDatatransferProgressListener> mListeners = new HashSet<OnDatatransferProgressListener>();
+ Set<OnDatatransferProgressListener> mDataTransferListeners = new HashSet<OnDatatransferProgressListener>();
public FileRequestEntity(final File file, final String contentType) {
super();
}
public void addOnDatatransferProgressListener(OnDatatransferProgressListener listener) {
- mListeners.add(listener);
+ mDataTransferListeners.add(listener);
}
public void addOnDatatransferProgressListeners(Collection<OnDatatransferProgressListener> listeners) {
- mListeners.addAll(listeners);
+ mDataTransferListeners.addAll(listeners);
}
public void removeOnDatatransferProgressListener(OnDatatransferProgressListener listener) {
- mListeners.remove(listener);
+ mDataTransferListeners.remove(listener);
}
public void writeRequest(final OutputStream out) throws IOException {
//byte[] tmp = new byte[4096];
ByteBuffer tmp = ByteBuffer.allocate(4096);
- int i = 0;
+ int readResult = 0;
// TODO(bprzybylski): each mem allocation can throw OutOfMemoryError we need to handle it
// globally in some fashionable manner
FileChannel channel = raf.getChannel();
FileLock lock = channel.tryLock();
Iterator<OnDatatransferProgressListener> it = null;
+ long transferred = 0;
+ long size = mFile.length();
+ if (size == 0) size = -1;
try {
- while ((i = channel.read(tmp)) >= 0) {
- out.write(tmp.array(), 0, i);
+ while ((readResult = channel.read(tmp)) >= 0) {
+ out.write(tmp.array(), 0, readResult);
tmp.clear();
- it = mListeners.iterator();
+ transferred += readResult;
+ it = mDataTransferListeners.iterator();
while (it.hasNext()) {
- it.next().onTransferProgress(i);
+ it.next().onTransferProgress(readResult, transferred, size, mFile.getName());
}
}
projects / pub / Android / ownCloud.git / commitdiff