import java.io.File;
import java.util.ArrayList;
+import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
-import java.util.List;
import java.util.Vector;
import com.owncloud.android.Log_OC;
import android.content.ContentProviderOperation;
import android.content.ContentProviderResult;
import android.content.ContentResolver;
+import android.content.ContentUris;
import android.content.ContentValues;
import android.content.OperationApplicationException;
import android.database.Cursor;
}
- public void saveFiles(List<OCFile> files) {
+ /**
+ * Inserts or updates the list of files contained in a given folder.
+ *
+ * @param folder
+ * @param files
+ * @param removeNotUpdated
+ */
+ public void saveFolder(OCFile folder, Collection<OCFile> updatedFiles, Collection<OCFile> filesToRemove) {
+
+ Log_OC.d(TAG, "Saving folder " + folder.getRemotePath() + " with " + updatedFiles.size() + " children and " + filesToRemove.size() + " files to remove");
- Iterator<OCFile> filesIt = files.iterator();
- ArrayList<ContentProviderOperation> operations = new ArrayList<ContentProviderOperation>(files.size());
- OCFile file = null;
+ ArrayList<ContentProviderOperation> operations = new ArrayList<ContentProviderOperation>(updatedFiles.size());
- // prepare operations to perform
- while (filesIt.hasNext()) {
- file = filesIt.next();
+ // prepare operations to insert or update files to save in the given folder
+ for (OCFile file : updatedFiles) {
ContentValues cv = new ContentValues();
cv.put(ProviderTableMeta.FILE_MODIFIED, file.getModificationTimestamp());
cv.put(ProviderTableMeta.FILE_MODIFIED_AT_LAST_SYNC_FOR_DATA, file.getModificationTimestampAtLastSyncForData());
cv.put(ProviderTableMeta.FILE_CONTENT_LENGTH, file.getFileLength());
cv.put(ProviderTableMeta.FILE_CONTENT_TYPE, file.getMimetype());
cv.put(ProviderTableMeta.FILE_NAME, file.getFileName());
- if (file.getParentId() != FileDataStorageManager.ROOT_PARENT_ID)
- cv.put(ProviderTableMeta.FILE_PARENT, file.getParentId());
+ //cv.put(ProviderTableMeta.FILE_PARENT, file.getParentId());
+ cv.put(ProviderTableMeta.FILE_PARENT, folder.getFileId());
cv.put(ProviderTableMeta.FILE_PATH, file.getRemotePath());
- if (!file.isFolder())
+ if (!file.isFolder()) {
cv.put(ProviderTableMeta.FILE_STORAGE_PATH, file.getStoragePath());
+ }
cv.put(ProviderTableMeta.FILE_ACCOUNT_OWNER, mAccount.name);
cv.put(ProviderTableMeta.FILE_LAST_SYNC_DATE, file.getLastSyncDateForProperties());
cv.put(ProviderTableMeta.FILE_LAST_SYNC_DATE_FOR_DATA, file.getLastSyncDateForData());
cv.put(ProviderTableMeta.FILE_KEEP_IN_SYNC, file.keepInSync() ? 1 : 0);
cv.put(ProviderTableMeta.FILE_ETAG, file.getEtag());
- if (fileExists(file.getRemotePath())) {
- OCFile oldFile = getFileByPath(file.getRemotePath());
- file.setFileId(oldFile.getFileId());
-
- if (file.isFolder()) {
- cv.put(ProviderTableMeta.FILE_CONTENT_LENGTH, oldFile.getFileLength());
- file.setFileLength(oldFile.getFileLength());
- }
+ boolean existsByPath = fileExists(file.getRemotePath());
+ if (existsByPath || fileExists(file.getFileId())) {
+ // updating an existing file
- operations.add(ContentProviderOperation.newUpdate(ProviderTableMeta.CONTENT_URI).
- withValues(cv).
- withSelection( ProviderTableMeta._ID + "=?",
- new String[] { String.valueOf(file.getFileId()) })
- .build());
-
- } else if (fileExists(file.getFileId())) {
- OCFile oldFile = getFileById(file.getFileId());
- if (file.getStoragePath() == null && oldFile.getStoragePath() != null)
- file.setStoragePath(oldFile.getStoragePath());
+ /* CALLER IS THE RESPONSIBLE FOR GRANTING RIGHT UPDATE OF INFORMATION, NOT THIS METHOD.
+ *
+ * HERE ONLY DATA CONSISTENCY SHOULD BE GRANTED
+ */
+ /*
+ OCFile oldFile = null;
+ if (existsByPath) {
+ // grant same id
+ oldFile = getFileByPath(file.getRemotePath());
+ file.setFileId(oldFile.getFileId());
+ } else {
+ oldFile = getFileById(file.getFileId());
+ }
- if (!file.isFolder())
- cv.put(ProviderTableMeta.FILE_STORAGE_PATH, file.getStoragePath());
- else {
- cv.put(ProviderTableMeta.FILE_CONTENT_LENGTH, oldFile.getFileLength());
+ if (file.isFolder()) {
+ // folders keep size information, since it's calculated
file.setFileLength(oldFile.getFileLength());
+ cv.put(ProviderTableMeta.FILE_CONTENT_LENGTH, oldFile.getFileLength());
+
+ } else if (file.getStoragePath() == null && oldFile.getStoragePath() != null) {
+ // regular files keep access to local contents, although it's lost in the new OCFile
+ file.setStoragePath(oldFile.getStoragePath());
+ cv.put(ProviderTableMeta.FILE_STORAGE_PATH, oldFile.getStoragePath());
}
+ */
operations.add(ContentProviderOperation.newUpdate(ProviderTableMeta.CONTENT_URI).
withValues(cv).
.build());
} else {
+ // adding a new file
operations.add(ContentProviderOperation.newInsert(ProviderTableMeta.CONTENT_URI).withValues(cv).build());
}
}
+
+ // prepare operations to remove files in the given folder
+ String where = ProviderTableMeta.FILE_ACCOUNT_OWNER + "=?" + " AND " + ProviderTableMeta.FILE_PATH + "=?";
+ String [] whereArgs = null;
+ for (OCFile file : filesToRemove) {
+ if (file.getParentId() == folder.getFileId()) {
+ whereArgs = new String[]{mAccount.name, file.getRemotePath()};
+ //Uri.withAppendedPath(ProviderTableMeta.CONTENT_URI_FILE, "" + file.getFileId());
+ if (file.isFolder()) {
+ operations.add(ContentProviderOperation
+ .newDelete(ContentUris.withAppendedId(ProviderTableMeta.CONTENT_URI_DIR, file.getFileId())).withSelection(where, whereArgs)
+ .build());
+ // TODO remove local folder
+ } else {
+ operations.add(ContentProviderOperation
+ .newDelete(ContentUris.withAppendedId(ProviderTableMeta.CONTENT_URI_FILE, file.getFileId())).withSelection(where, whereArgs)
+ .build());
+ if (file.isDown()) {
+ new File(file.getStoragePath()).delete();
+ // TODO move the deletion of local contents after success of deletions
+ }
+ }
+ }
+ }
+
+ // update metadata of folder --> TODO MOVE UPDATE OF SIZE TO CONTENTPROVIDER
+ ContentValues cv = new ContentValues();
+ cv.put(ProviderTableMeta.FILE_MODIFIED, folder.getModificationTimestamp());
+ cv.put(ProviderTableMeta.FILE_MODIFIED_AT_LAST_SYNC_FOR_DATA, folder.getModificationTimestampAtLastSyncForData());
+ cv.put(ProviderTableMeta.FILE_CREATION, folder.getCreationTimestamp());
+ cv.put(ProviderTableMeta.FILE_CONTENT_LENGTH, folder.getFileLength());
+ cv.put(ProviderTableMeta.FILE_CONTENT_TYPE, folder.getMimetype());
+ cv.put(ProviderTableMeta.FILE_NAME, folder.getFileName());
+ cv.put(ProviderTableMeta.FILE_PARENT, folder.getParentId());
+ cv.put(ProviderTableMeta.FILE_PATH, folder.getRemotePath());
+ if (!folder.isFolder()) {
+ cv.put(ProviderTableMeta.FILE_STORAGE_PATH, folder.getStoragePath());
+ }
+ cv.put(ProviderTableMeta.FILE_ACCOUNT_OWNER, mAccount.name);
+ cv.put(ProviderTableMeta.FILE_LAST_SYNC_DATE, folder.getLastSyncDateForProperties());
+ cv.put(ProviderTableMeta.FILE_LAST_SYNC_DATE_FOR_DATA, folder.getLastSyncDateForData());
+ cv.put(ProviderTableMeta.FILE_KEEP_IN_SYNC, folder.keepInSync() ? 1 : 0);
+ cv.put(ProviderTableMeta.FILE_ETAG, folder.getEtag());
+ operations.add(ContentProviderOperation.newUpdate(ProviderTableMeta.CONTENT_URI).
+ withValues(cv).
+ withSelection( ProviderTableMeta._ID + "=?",
+ new String[] { String.valueOf(folder.getFileId()) })
+ .build());
// apply operations in batch
ContentProviderResult[] results = null;
+ Log_OC.d(TAG, "Sending " + operations.size() + " operations to FileContentProvider");
try {
if (getContentResolver() != null) {
results = getContentResolver().applyBatch(ProviderMeta.AUTHORITY_FILES, operations);
}
} catch (OperationApplicationException e) {
- Log_OC.e(TAG, "Fail to update/insert list of files to database " + e.getMessage());
+ Log_OC.e(TAG, "Exception in batch of operations " + e.getMessage());
} catch (RemoteException e) {
- Log_OC.e(TAG, "Fail to update/insert list of files to database " + e.getMessage());
+ Log_OC.e(TAG, "Exception in batch of operations " + e.getMessage());
}
// update new id in file objects for insertions
if (results != null) {
long newId;
+ Iterator<OCFile> filesIt = updatedFiles.iterator();
+ OCFile file = null;
for (int i=0; i<results.length; i++) {
+ if (filesIt.hasNext()) {
+ file = filesIt.next();
+ } else {
+ file = null;
+ }
if (results[i].uri != null) {
newId = Long.parseLong(results[i].uri.getPathSegments().get(1));
- files.get(i).setFileId(newId);
- //Log_OC.v(TAG, "Found and added id in insertion for " + files.get(i).getRemotePath());
+ //updatedFiles.get(i).setFileId(newId);
+ if (file != null) {
+ file.setFileId(newId);
+ }
}
}
}
-
- for (OCFile aFile : files) {
- if (aFile.isFolder() && aFile.needsUpdatingWhileSaving())
- saveFiles(getFolderContent(aFile));
- }
-
+
}
}
- public void removeFile(OCFile file, boolean removeLocalCopy) {
- Uri file_uri = Uri.withAppendedPath(ProviderTableMeta.CONTENT_URI_FILE, ""+file.getFileId());
+ public void removeFile(OCFile file, boolean removeDBData, boolean removeLocalCopy) {
+ if (file != null) {
+ if (file.isFolder()) {
+ removeFolder(file, removeDBData, removeLocalCopy);
+
+ } else {
+ if (removeDBData) {
+ //Uri file_uri = Uri.withAppendedPath(ProviderTableMeta.CONTENT_URI_FILE, ""+file.getFileId());
+ Uri file_uri = ContentUris.withAppendedId(ProviderTableMeta.CONTENT_URI_FILE, file.getFileId());
+ String where = ProviderTableMeta.FILE_ACCOUNT_OWNER + "=?" + " AND " + ProviderTableMeta.FILE_PATH + "=?";
+ String [] whereArgs = new String[]{mAccount.name, file.getRemotePath()};
+ if (getContentProviderClient() != null) {
+ try {
+ getContentProviderClient().delete(file_uri, where, whereArgs);
+ } catch (RemoteException e) {
+ e.printStackTrace();
+ }
+ } else {
+ getContentResolver().delete(file_uri, where, whereArgs);
+ }
+ if (file.getFileLength() > 0) {
+ updateSizesToTheRoot(file.getParentId()); // TODO move to content provider
+ }
+ }
+ if (removeLocalCopy && file.isDown()) {
+ boolean success = new File(file.getStoragePath()).delete();
+ if (!removeDBData && success) {
+ // maybe unnecessary, but should be checked TODO remove if unnecessary
+ file.setStoragePath(null);
+ saveFile(file);
+ }
+ }
+ }
+ }
+ }
+
+
+ public void removeFolder(OCFile folder, boolean removeDBData, boolean removeLocalContent) {
+ if (folder != null && folder.isFolder()) {
+ if (removeDBData && folder.getFileId() != -1) {
+ removeFolderInDb(folder);
+ }
+ if (removeLocalContent) {
+ File localFolder = new File(FileStorageUtils.getDefaultSavePathFor(mAccount.name, folder));
+ removeLocalFolder(localFolder);
+ }
+ }
+ }
+
+ private void removeFolderInDb(OCFile folder) {
+ Uri folder_uri = Uri.withAppendedPath(ProviderTableMeta.CONTENT_URI_DIR, ""+ folder.getFileId()); // URI for recursive deletion
+ String where = ProviderTableMeta.FILE_ACCOUNT_OWNER + "=?" + " AND " + ProviderTableMeta.FILE_PATH + "=?";
+ String [] whereArgs = new String[]{mAccount.name, folder.getRemotePath()};
if (getContentProviderClient() != null) {
try {
- getContentProviderClient().delete(file_uri,
- ProviderTableMeta.FILE_ACCOUNT_OWNER+"=?",
- new String[]{mAccount.name});
+ getContentProviderClient().delete(folder_uri, where, whereArgs);
} catch (RemoteException e) {
e.printStackTrace();
}
} else {
- getContentResolver().delete(file_uri,
- ProviderTableMeta.FILE_ACCOUNT_OWNER+"=?",
- new String[]{mAccount.name});
- }
- if (file.isDown() && removeLocalCopy) {
- new File(file.getStoragePath()).delete();
- }
- if (file.isFolder() && removeLocalCopy) {
- File f = new File(FileStorageUtils.getDefaultSavePathFor(mAccount.name, file));
- if (f.exists() && f.isDirectory() && (f.list() == null || f.list().length == 0)) {
- f.delete();
- }
+ getContentResolver().delete(folder_uri, where, whereArgs);
}
-
- if (file.getFileLength() > 0) {
- updateSizesToTheRoot(file.getParentId());
+ if (folder.getFileLength() > 0) {
+ updateSizesToTheRoot(folder.getParentId()); // TODO move to FileContentProvider
}
}
- public void removeFolder(OCFile folder, boolean removeDBData, boolean removeLocalContent) {
- // TODO consider possible failures
- if (folder != null && folder.isFolder() && folder.getFileId() != -1) {
- Vector<OCFile> children = getFolderContent(folder);
- if (children.size() > 0) {
- OCFile child = null;
- for (int i=0; i<children.size(); i++) {
- child = children.get(i);
- if (child.isFolder()) {
- removeFolder(child, removeDBData, removeLocalContent);
+ private void removeLocalFolder(File folder) {
+ if (folder.exists()) {
+ File[] files = folder.listFiles();
+ if (files != null) {
+ for (File file : files) {
+ if (file.isDirectory()) {
+ removeLocalFolder(file);
} else {
- if (removeDBData) {
- removeFile(child, removeLocalContent);
- } else if (removeLocalContent) {
- if (child.isDown()) {
- new File(child.getStoragePath()).delete();
- }
- }
+ file.delete();
}
}
}
- if (removeDBData) {
- removeFile(folder, true);
- }
-
- if (folder.getFileLength() > 0) {
- updateSizesToTheRoot(folder.getParentId());
- }
+ folder.delete();
}
}
-
/**
* Updates database for a folder that was moved to a different location.
*
delete = new DeleteMethod(client.getBaseUri() + WebdavUtils.encodePath(mFileToRemove.getRemotePath()));
int status = client.executeMethod(delete, REMOVE_READ_TIMEOUT, REMOVE_CONNECTION_TIMEOUT);
if (delete.succeeded() || status == HttpStatus.SC_NOT_FOUND) {
- if (mFileToRemove.isFolder()) {
- mDataStorageManager.removeFolder(mFileToRemove, true, mDeleteLocalCopy);
- } else {
- mDataStorageManager.removeFile(mFileToRemove, mDeleteLocalCopy);
- }
+ mDataStorageManager.removeFile(mFileToRemove, true, mDeleteLocalCopy);
}
delete.getResponseBodyAsString(); // exhaust the response, although not interesting
result = new RemoteOperationResult((delete.succeeded() || status == HttpStatus.SC_NOT_FOUND), status, delete.getResponseHeaders());
mStorageManager.saveFile(remoteFolder);
}
+ Log_OC.d(TAG, "Remote folder " + mLocalFolder.getRemotePath() + " didn't change");
mChildren = mStorageManager.getFolderContent(mLocalFolder);
} else {
- // read info of folder contents
+ Log_OC.d(TAG, "Remote folder " + mLocalFolder.getRemotePath() + " changed - starting update of local data ");
+
List<OCFile> updatedFiles = new Vector<OCFile>(dataInServer.getResponses().length - 1);
List<SynchronizeFileOperation> filesToSyncContents = new Vector<SynchronizeFileOperation>();
+
+ // get current data about local contents of the folder to synchronize
+ List<OCFile> localFiles = mStorageManager.getFolderContent(mLocalFolder);
+ Map<String, OCFile> localFilesMap = new HashMap<String, OCFile>(localFiles.size());
+ for (OCFile file : localFiles) {
+ localFilesMap.put(file.getRemotePath(), file);
+ }
// loop to update every child
OCFile remoteFile = null, localFile = null;
remoteFile.setParentId(mLocalFolder.getFileId());
/// retrieve local data for the read file
- localFile = mStorageManager.getFileByPath(remoteFile.getRemotePath());
+ //localFile = mStorageManager.getFileByPath(remoteFile.getRemotePath());
+ localFile = localFilesMap.remove(remoteFile.getRemotePath());
/// add to the remoteFile (the new one) data about LOCAL STATE (not existing in the server side)
remoteFile.setLastSyncDateForProperties(mCurrentSyncTime);
if (localFile != null) {
- // properties of local state are kept unmodified
+ // some properties of local state are kept unmodified
+ remoteFile.setFileId(localFile.getFileId());
remoteFile.setKeepInSync(localFile.keepInSync());
remoteFile.setLastSyncDateForData(localFile.getLastSyncDateForData());
remoteFile.setModificationTimestampAtLastSyncForData(localFile.getModificationTimestampAtLastSyncForData());
remoteFile.setEtag(""); // remote eTag will not be updated unless contents are synchronized (Synchronize[File|Folder]Operation with remoteFile as parameter)
}
- /// check and fix, if need, local storage path
+ /// check and fix, if needed, local storage path
checkAndFixForeignStoragePath(remoteFile); // fixing old policy - now local files must be copied into the ownCloud local folder
searchForLocalFileInDefaultPath(remoteFile); // legacy
}
// save updated contents in local database; all at once, trying to get a best performance in database update (not a big deal, indeed)
- mStorageManager.saveFiles(updatedFiles);
+ mStorageManager.saveFolder(remoteFolder, updatedFiles, localFilesMap.values());
// request for the synchronization of file contents AFTER saving current remote properties
startContentSynchronizations(filesToSyncContents, client);
// removal of obsolete files
- removeObsoleteFiles();
+ //removeObsoleteFiles();
// must be done AFTER saving all the children information, so that eTag is not updated in the database in case of unexpected exceptions
- mStorageManager.saveFile(remoteFolder);
+ //mStorageManager.saveFile(remoteFolder);
+ mChildren = updatedFiles;
}
}
-
- /**
- * Removes obsolete children in the folder after saving all the new data.
- */
- private void removeObsoleteFiles() {
- mChildren = mStorageManager.getFolderContent(mLocalFolder);
- OCFile file;
- for (int i=0; i < mChildren.size(); ) {
- file = mChildren.get(i);
- if (file.getLastSyncDateForProperties() != mCurrentSyncTime) {
- if (file.isFolder()) {
- Log_OC.d(TAG, "removing folder: " + file);
- mStorageManager.removeFolder(file, true, true);
- } else {
- Log_OC.d(TAG, "removing file: " + file);
- mStorageManager.removeFile(file, true);
- }
- mChildren.remove(i);
- } else {
- i++;
- }
- }
- }
-
-
/**
* Performs a list of synchronization operations, determining if a download or upload is needed or
* if exists conflict due to changes both in local and remote contents of the each file.
package com.owncloud.android.providers;
+import java.util.ArrayList;
import java.util.HashMap;
import com.owncloud.android.Log_OC;
import android.content.ContentProvider;
+import android.content.ContentProviderOperation;
+import android.content.ContentProviderResult;
import android.content.ContentUris;
import android.content.ContentValues;
import android.content.Context;
+import android.content.OperationApplicationException;
import android.content.UriMatcher;
import android.database.Cursor;
import android.database.SQLException;
import android.database.sqlite.SQLiteQueryBuilder;
import android.net.Uri;
import android.text.TextUtils;
+import android.util.Log;
/**
* The ContentProvider for the ownCloud App.
*
* @author Bartek Przybylski
+ * @author David A. Velasco
*
*/
public class FileContentProvider extends ContentProvider {
ProviderTableMeta.FILE_ETAG);
}
+ private static final String TAG = FileContentProvider.class.getSimpleName();
private static final int SINGLE_FILE = 1;
private static final int DIRECTORY = 2;
private static final int ROOT_DIRECTORY = 3;
@Override
public int delete(Uri uri, String where, String[] whereArgs) {
+ //Log_OC.d(TAG, "Deleting " + uri + " at provider " + this);
+ int count = 0;
SQLiteDatabase db = mDbHelper.getWritableDatabase();
+ db.beginTransaction();
+ try {
+ count = delete(db, uri, where, whereArgs);
+ db.setTransactionSuccessful();
+ } finally {
+ db.endTransaction();
+ }
+ getContext().getContentResolver().notifyChange(uri, null);
+ return count;
+ }
+
+
+ private int delete(SQLiteDatabase db, Uri uri, String where, String[] whereArgs) {
int count = 0;
switch (mUriMatcher.match(uri)) {
case SINGLE_FILE:
+ /*Cursor c = query(db, uri, null, where, whereArgs, null);
+ String remotePath = "(unexisting)";
+ if (c != null && c.moveToFirst()) {
+ remotePath = c.getString(c.getColumnIndex(ProviderTableMeta.FILE_PATH));
+ }
+ Log_OC.d(TAG, "Removing FILE " + remotePath);
+ */
count = db.delete(ProviderTableMeta.DB_NAME,
ProviderTableMeta._ID
+ "="
+ uri.getPathSegments().get(1)
+ (!TextUtils.isEmpty(where) ? " AND (" + where
+ ")" : ""), whereArgs);
+ /* just for log
+ if (c!=null) {
+ c.close();
+ }
+ */
+ break;
+ case DIRECTORY:
+ // deletion of folder is recursive
+ /*
+ Uri folderUri = ContentUris.withAppendedId(ProviderTableMeta.CONTENT_URI_FILE, Long.parseLong(uri.getPathSegments().get(1)));
+ Cursor folder = query(db, folderUri, null, null, null, null);
+ String folderName = "(unknown)";
+ if (folder != null && folder.moveToFirst()) {
+ folderName = folder.getString(folder.getColumnIndex(ProviderTableMeta.FILE_PATH));
+ }
+ */
+ Cursor children = query(uri, null, null, null, null);
+ if (children != null && children.moveToFirst()) {
+ long childId;
+ boolean isDir;
+ String remotePath;
+ while (!children.isAfterLast()) {
+ childId = children.getLong(children.getColumnIndex(ProviderTableMeta._ID));
+ isDir = "DIR".equals(children.getString(children.getColumnIndex(ProviderTableMeta.FILE_CONTENT_TYPE)));
+ remotePath = children.getString(children.getColumnIndex(ProviderTableMeta.FILE_PATH));
+ if (isDir) {
+ count += delete(db, ContentUris.withAppendedId(ProviderTableMeta.CONTENT_URI_DIR, childId), null, null);
+ } else {
+ count += delete(db, ContentUris.withAppendedId(ProviderTableMeta.CONTENT_URI_FILE, childId), null, null);
+ }
+ children.moveToNext();
+ }
+ children.close();
+ } /*else {
+ Log_OC.d(TAG, "No child to remove in DIRECTORY " + folderName);
+ }
+ Log_OC.d(TAG, "Removing DIRECTORY " + folderName + " (or maybe not) ");
+ */
+ count += db.delete(ProviderTableMeta.DB_NAME,
+ ProviderTableMeta._ID
+ + "="
+ + uri.getPathSegments().get(1)
+ + (!TextUtils.isEmpty(where) ? " AND (" + where
+ + ")" : ""), whereArgs);
+ /* Just for log
+ if (folder != null) {
+ folder.close();
+ }*/
break;
case ROOT_DIRECTORY:
+ //Log_OC.d(TAG, "Removing ROOT!");
count = db.delete(ProviderTableMeta.DB_NAME, where, whereArgs);
break;
default:
+ //Log_OC.e(TAG, "Unknown uri " + uri);
throw new IllegalArgumentException("Unknown uri: " + uri.toString());
}
- getContext().getContentResolver().notifyChange(uri, null);
return count;
}
+
@Override
public String getType(Uri uri) {
@Override
public Uri insert(Uri uri, ContentValues values) {
+ //Log_OC.d(TAG, "Inserting " + values.getAsString(ProviderTableMeta.FILE_PATH) + " at provider " + this);
+ Uri newUri = null;
+ SQLiteDatabase db = mDbHelper.getWritableDatabase();
+ db.beginTransaction();
+ try {
+ newUri = insert(db, uri, values);
+ db.setTransactionSuccessful();
+ } finally {
+ db.endTransaction();
+ }
+ getContext().getContentResolver().notifyChange(newUri, null);
+ return newUri;
+ }
+
+ private Uri insert(SQLiteDatabase db, Uri uri, ContentValues values) {
if (mUriMatcher.match(uri) != SINGLE_FILE &&
- mUriMatcher.match(uri) != ROOT_DIRECTORY) {
-
+ mUriMatcher.match(uri) != ROOT_DIRECTORY) {
+ //Log_OC.e(TAG, "Inserting invalid URI: " + uri);
throw new IllegalArgumentException("Unknown uri id: " + uri);
}
- SQLiteDatabase db = mDbHelper.getWritableDatabase();
long rowId = db.insert(ProviderTableMeta.DB_NAME, null, values);
if (rowId > 0) {
- Uri insertedFileUri = ContentUris.withAppendedId(
- ProviderTableMeta.CONTENT_URI_FILE, rowId);
- getContext().getContentResolver().notifyChange(insertedFileUri,
- null);
+ Uri insertedFileUri = ContentUris.withAppendedId(ProviderTableMeta.CONTENT_URI_FILE, rowId);
+ //Log_OC.d(TAG, "Inserted " + values.getAsString(ProviderTableMeta.FILE_PATH) + " at provider " + this);
return insertedFileUri;
+ } else {
+ //Log_OC.d(TAG, "Error while inserting " + values.getAsString(ProviderTableMeta.FILE_PATH) + " at provider " + this);
+ throw new SQLException("ERROR " + uri);
}
- throw new SQLException("ERROR " + uri);
}
+
@Override
public boolean onCreate() {
mDbHelper = new DataBaseHelper(getContext());
return true;
}
+
@Override
- public Cursor query(Uri uri, String[] projection, String selection,
- String[] selectionArgs, String sortOrder) {
+ public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder) {
+ Cursor result = null;
+ SQLiteDatabase db = mDbHelper.getReadableDatabase();
+ db.beginTransaction();
+ try {
+ result = query(db, uri, projection, selection, selectionArgs, sortOrder);
+ db.setTransactionSuccessful();
+ } finally {
+ db.endTransaction();
+ }
+ return result;
+ }
+
+ private Cursor query(SQLiteDatabase db, Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder) {
SQLiteQueryBuilder sqlQuery = new SQLiteQueryBuilder();
sqlQuery.setTables(ProviderTableMeta.DB_NAME);
order = sortOrder;
}
- SQLiteDatabase db = mDbHelper.getReadableDatabase();
// DB case_sensitive
db.execSQL("PRAGMA case_sensitive_like = true");
- Cursor c = sqlQuery.query(db, projection, selection, selectionArgs,
- null, null, order);
+ Cursor c = sqlQuery.query(db, projection, selection, selectionArgs, null, null, order);
c.setNotificationUri(getContext().getContentResolver(), uri);
-
return c;
}
@Override
- public int update(Uri uri, ContentValues values, String selection,
- String[] selectionArgs) {
- return mDbHelper.getWritableDatabase().update(
- ProviderTableMeta.DB_NAME, values, selection, selectionArgs);
+ public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
+
+ //Log_OC.d(TAG, "Updating " + values.getAsString(ProviderTableMeta.FILE_PATH) + " at provider " + this);
+ int count = 0;
+ SQLiteDatabase db = mDbHelper.getWritableDatabase();
+ db.beginTransaction();
+ try {
+ count = update(db, uri, values, selection, selectionArgs);
+ db.setTransactionSuccessful();
+ } finally {
+ db.endTransaction();
+ }
+ getContext().getContentResolver().notifyChange(uri, null);
+ return count;
+ }
+
+
+ private int update(SQLiteDatabase db, Uri uri, ContentValues values, String selection, String[] selectionArgs) {
+ return db.update(ProviderTableMeta.DB_NAME, values, selection, selectionArgs);
+ }
+
+
+ @Override
+ public ContentProviderResult[] applyBatch (ArrayList<ContentProviderOperation> operations) throws OperationApplicationException {
+ //Log.d(TAG, "applying batch in provider " + this + " (temporary: " + isTemporary() + ")" );
+ ContentProviderResult[] results = new ContentProviderResult[operations.size()];
+ int i=0;
+
+ SQLiteDatabase db = mDbHelper.getWritableDatabase();
+ db.beginTransaction(); // it's supposed that transactions can be nested
+ try {
+ for (ContentProviderOperation operation : operations) {
+ results[i] = operation.apply(this, results, i);
+ i++;
+ }
+ db.setTransactionSuccessful();
+ } finally {
+ db.endTransaction();
+ }
+ //Log.d(TAG, "applied batch in provider " + this);
+ return results;
}
+
class DataBaseHelper extends SQLiteOpenHelper {
public DataBaseHelper(Context context) {
String accountName = intent.getStringExtra(FileSyncService.ACCOUNT_NAME);
RemoteOperationResult synchResult = (RemoteOperationResult)intent.getSerializableExtra(FileSyncService.SYNC_RESULT);
- Log_OC.d(TAG, "sync of account " + accountName + " is in_progress: " + inProgress);
-
if (getAccount() != null && accountName.equals(getAccount().name)) {
String synchFolderRemotePath = intent.getStringExtra(FileSyncService.SYNC_FOLDER_REMOTE_PATH);
@Override
public void onNeutral(String callerTag) {
- File f = null;
- if (mTargetFile.isFolder()) {
- // TODO run in a secondary thread?
- mContainerActivity.getStorageManager().removeFolder(mTargetFile, false, true);
-
- } else if (mTargetFile.isDown() && (f = new File(mTargetFile.getStoragePath())).exists()) {
- f.delete();
- mTargetFile.setStoragePath(null);
- mContainerActivity.getStorageManager().saveFile(mTargetFile);
- }
+ mContainerActivity.getStorageManager().removeFile(mTargetFile, false, true); // TODO perform in background task / new thread
listDirectory();
mContainerActivity.onTransferStateChanged(mTargetFile, false, false);
}
try {
method.setFollowRedirects(mFollowRedirects);
} catch (Exception e) {
- if (mFollowRedirects) Log_OC.d(TAG, "setFollowRedirects failed for " + method.getName() + " method, custom redirection will be used");
+ //if (mFollowRedirects) Log_OC.d(TAG, "setFollowRedirects failed for " + method.getName() + " method, custom redirection will be used if needed");
customRedirectionNeeded = mFollowRedirects;
}
if (mSsoSessionCookie != null && mSsoSessionCookie.length() > 0) {
projects / pub / Android / ownCloud.git / commitdiff