src/com/owncloud/android/providers/FileContentProvider.java

   1 /* ownCloud Android client application
   2  *   Copyright (C) 2011  Bartek Przybylski
   3  *   Copyright (C) 2012-2013 ownCloud Inc.
   4  *
   5  *   This program is free software: you can redistribute it and/or modify
   6  *   it under the terms of the GNU General Public License version 2,
   7  *   as published by the Free Software Foundation.
   8  *
   9  *   This program is distributed in the hope that it will be useful,
  10  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  *   GNU General Public License for more details.
  13  *
  14  *   You should have received a copy of the GNU General Public License
  15  *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16  *
  17  */
  18
  19 package com.owncloud.android.providers;
  20
  21 import java.util.ArrayList;
  22 import java.util.HashMap;
  23
  24 import com.owncloud.android.R;
  25 import com.owncloud.android.db.ProviderMeta;
  26 import com.owncloud.android.db.ProviderMeta.ProviderTableMeta;
  27 import com.owncloud.android.lib.resources.files.FileUtils;
  28 import com.owncloud.android.lib.resources.shares.ShareType;
  29 import com.owncloud.android.utils.Log_OC;
  30
  31
  32
  33 import android.content.ContentProvider;
  34 import android.content.ContentProviderOperation;
  35 import android.content.ContentProviderResult;
  36 import android.content.ContentUris;
  37 import android.content.ContentValues;
  38 import android.content.Context;
  39 import android.content.OperationApplicationException;
  40 import android.content.UriMatcher;
  41 import android.database.Cursor;
  42 import android.database.SQLException;
  43 import android.database.sqlite.SQLiteDatabase;
  44 import android.database.sqlite.SQLiteOpenHelper;
  45 import android.database.sqlite.SQLiteQueryBuilder;
  46 import android.net.Uri;
  47 import android.text.TextUtils;
  48
  49 /**
  50  * The ContentProvider for the ownCloud App.
  51  *
  52  * @author Bartek Przybylski
  53  * @author David A. Velasco
  54  *
  55  */
  56 public class FileContentProvider extends ContentProvider {
  57
  58     private DataBaseHelper mDbHelper;
  59
  60     // Projection for filelist table
  61     private static HashMap<String, String> mFileProjectionMap;
  62     static {
  63         mFileProjectionMap = new HashMap<String, String>();
  64         mFileProjectionMap.put(ProviderTableMeta._ID, ProviderTableMeta._ID);
  65         mFileProjectionMap.put(ProviderTableMeta.FILE_PARENT,
  66                 ProviderTableMeta.FILE_PARENT);
  67         mFileProjectionMap.put(ProviderTableMeta.FILE_PATH,
  68                 ProviderTableMeta.FILE_PATH);
  69         mFileProjectionMap.put(ProviderTableMeta.FILE_NAME,
  70                 ProviderTableMeta.FILE_NAME);
  71         mFileProjectionMap.put(ProviderTableMeta.FILE_CREATION,
  72                 ProviderTableMeta.FILE_CREATION);
  73         mFileProjectionMap.put(ProviderTableMeta.FILE_MODIFIED,
  74                 ProviderTableMeta.FILE_MODIFIED);
  75         mFileProjectionMap.put(ProviderTableMeta.FILE_MODIFIED_AT_LAST_SYNC_FOR_DATA,
  76                 ProviderTableMeta.FILE_MODIFIED_AT_LAST_SYNC_FOR_DATA);
  77         mFileProjectionMap.put(ProviderTableMeta.FILE_CONTENT_LENGTH,
  78                 ProviderTableMeta.FILE_CONTENT_LENGTH);
  79         mFileProjectionMap.put(ProviderTableMeta.FILE_CONTENT_TYPE,
  80                 ProviderTableMeta.FILE_CONTENT_TYPE);
  81         mFileProjectionMap.put(ProviderTableMeta.FILE_STORAGE_PATH,
  82                 ProviderTableMeta.FILE_STORAGE_PATH);
  83         mFileProjectionMap.put(ProviderTableMeta.FILE_LAST_SYNC_DATE,
  84                 ProviderTableMeta.FILE_LAST_SYNC_DATE);
  85         mFileProjectionMap.put(ProviderTableMeta.FILE_LAST_SYNC_DATE_FOR_DATA,
  86                 ProviderTableMeta.FILE_LAST_SYNC_DATE_FOR_DATA);
  87         mFileProjectionMap.put(ProviderTableMeta.FILE_KEEP_IN_SYNC,
  88                 ProviderTableMeta.FILE_KEEP_IN_SYNC);
  89         mFileProjectionMap.put(ProviderTableMeta.FILE_ACCOUNT_OWNER,
  90                 ProviderTableMeta.FILE_ACCOUNT_OWNER);
  91         mFileProjectionMap.put(ProviderTableMeta.FILE_ETAG,
  92                 ProviderTableMeta.FILE_ETAG);
  93         mFileProjectionMap.put(ProviderTableMeta.FILE_SHARE_BY_LINK,
  94                 ProviderTableMeta.FILE_SHARE_BY_LINK);
  95         mFileProjectionMap.put(ProviderTableMeta.FILE_PUBLIC_LINK,
  96                 ProviderTableMeta.FILE_PUBLIC_LINK);
  97     }
  98
  99     private static final int SINGLE_FILE = 1;
 100     private static final int DIRECTORY = 2;
 101     private static final int ROOT_DIRECTORY = 3;
 102     private static final int SHARES = 4;
 103
 104     private static final String TAG = FileContentProvider.class.getSimpleName();
 105
 106     // Projection for ocshares table
 107     private static HashMap<String, String> mOCSharesProjectionMap;
 108     static {
 109         mOCSharesProjectionMap = new HashMap<String, String>();
 110         mOCSharesProjectionMap.put(ProviderTableMeta._ID, ProviderTableMeta._ID);
 111         mOCSharesProjectionMap.put(ProviderTableMeta.OCSHARES_FILE_SOURCE,
 112                 ProviderTableMeta.OCSHARES_FILE_SOURCE);
 113         mOCSharesProjectionMap.put(ProviderTableMeta.OCSHARES_ITEM_SOURCE,
 114                 ProviderTableMeta.OCSHARES_ITEM_SOURCE);
 115         mOCSharesProjectionMap.put(ProviderTableMeta.OCSHARES_SHARE_TYPE,
 116                 ProviderTableMeta.OCSHARES_SHARE_TYPE);
 117         mOCSharesProjectionMap.put(ProviderTableMeta.OCSHARES_SHARE_WITH,
 118                 ProviderTableMeta.OCSHARES_SHARE_WITH);
 119         mOCSharesProjectionMap.put(ProviderTableMeta.OCSHARES_PATH,
 120                 ProviderTableMeta.OCSHARES_PATH);
 121         mOCSharesProjectionMap.put(ProviderTableMeta.OCSHARES_PERMISSIONS,
 122                 ProviderTableMeta.OCSHARES_PERMISSIONS);
 123         mOCSharesProjectionMap.put(ProviderTableMeta.OCSHARES_SHARED_DATE,
 124                 ProviderTableMeta.OCSHARES_SHARED_DATE);
 125         mOCSharesProjectionMap.put(ProviderTableMeta.OCSHARES_EXPIRATION_DATE,
 126                 ProviderTableMeta.OCSHARES_EXPIRATION_DATE);
 127         mOCSharesProjectionMap.put(ProviderTableMeta.OCSHARES_TOKEN,
 128                 ProviderTableMeta.OCSHARES_TOKEN);
 129         mOCSharesProjectionMap.put(ProviderTableMeta.OCSHARES_SHARE_WITH_DISPLAY_NAME,
 130                 ProviderTableMeta.OCSHARES_SHARE_WITH_DISPLAY_NAME);
 131         mOCSharesProjectionMap.put(ProviderTableMeta.OCSHARES_IS_DIRECTORY,
 132                 ProviderTableMeta.OCSHARES_IS_DIRECTORY);
 133         mOCSharesProjectionMap.put(ProviderTableMeta.OCSHARES_USER_ID,
 134                 ProviderTableMeta.OCSHARES_USER_ID);
 135         mOCSharesProjectionMap.put(ProviderTableMeta.OCSHARES_ID_REMOTE_SHARED,
 136                 ProviderTableMeta.OCSHARES_ID_REMOTE_SHARED);
 137         mOCSharesProjectionMap.put(ProviderTableMeta.OCSHARES_ACCOUNT_OWNER,
 138                 ProviderTableMeta.OCSHARES_ACCOUNT_OWNER);
 139     }
 140
 141     private UriMatcher mUriMatcher;
 142
 143     @Override
 144     public int delete(Uri uri, String where, String[] whereArgs) {
 145         Log_OC.d(TAG, "Deleting " + uri + " at provider " + this);
 146         int count = 0;
 147         SQLiteDatabase db = mDbHelper.getWritableDatabase();
 148         db.beginTransaction();
 149
 150         // Get parentId to notify the change
 151         long parentId = getParentId(uri);
 152
 153         // Delete action
 154         try {
 155             count = delete(db, uri, where, whereArgs);
 156             db.setTransactionSuccessful();
 157         } finally {
 158             db.endTransaction();
 159         }
 160         Log_OC.d(TAG, "Uri " + uri);
 161         getContext().getContentResolver().notifyChange(uri, null);
 162
 163         // Notify the change to the parent folder
 164         notifyChangeToParentUri(parentId);
 165         return count;
 166     }
 167
 168     private long getParentId(Uri uri) {
 169         long parentId = -1;
 170
 171         if (mUriMatcher.match(uri) == SINGLE_FILE || mUriMatcher.match(uri) == DIRECTORY) {
 172             String fileId = uri.toString().substring(uri.toString().lastIndexOf(FileUtils.PATH_SEPARATOR) + 1);
 173             Uri selectFileUri = Uri.withAppendedPath(ProviderTableMeta.CONTENT_URI_FILE, fileId);
 174             String[] fileProjection = new String[] { ProviderTableMeta.FILE_PARENT };
 175             Cursor fileCursor = query(selectFileUri, fileProjection, null, null, null);
 176
 177             if (fileCursor != null  && fileCursor.moveToFirst()) {
 178                 parentId = fileCursor.getLong(fileCursor.getColumnIndex(ProviderTableMeta.FILE_PARENT));
 179             }
 180             fileCursor.close();
 181         }
 182         Log_OC.d(TAG, "getParentId = " + parentId);
 183         return parentId;
 184     }
 185
 186     private void notifyChangeToParentUri(long parentId) {
 187         if (parentId != -1) {
 188             Uri parentUri = Uri.withAppendedPath(
 189                     ProviderTableMeta.CONTENT_URI_DIR,
 190                     String.valueOf(parentId));
 191             Log_OC.d(TAG, "ParentUri " + parentUri);
 192             getContext().getContentResolver().notifyChange(parentUri, null);
 193         }
 194     }
 195
 196     private int delete(SQLiteDatabase db, Uri uri, String where, String[] whereArgs) {
 197         int count = 0;
 198         switch (mUriMatcher.match(uri)) {
 199         case SINGLE_FILE:
 200             /*Cursor c = query(db, uri, null, where, whereArgs, null);
 201             String remotePath = "(unexisting)";
 202             if (c != null && c.moveToFirst()) {
 203                 remotePath = c.getString(c.getColumnIndex(ProviderTableMeta.FILE_PATH));
 204             }
 205             Log_OC.d(TAG, "Removing FILE " + remotePath);
 206             */
 207             count = db.delete(ProviderTableMeta.FILE_TABLE_NAME,
 208                     ProviderTableMeta._ID
 209                             + "="
 210                             + uri.getPathSegments().get(1)
 211                             + (!TextUtils.isEmpty(where) ? " AND (" + where
 212                                     + ")" : ""), whereArgs);
 213             /* just for log
 214             if (c!=null) {
 215                 c.close();
 216             }
 217             */
 218             break;
 219         case DIRECTORY:
 220             // deletion of folder is recursive
 221             /*
 222             Uri folderUri = ContentUris.withAppendedId(ProviderTableMeta.CONTENT_URI_FILE, Long.parseLong(uri.getPathSegments().get(1)));
 223             Cursor folder = query(db, folderUri, null, null, null, null);
 224             String folderName = "(unknown)";
 225             if (folder != null && folder.moveToFirst()) {
 226                 folderName = folder.getString(folder.getColumnIndex(ProviderTableMeta.FILE_PATH));
 227             }
 228             */
 229             Cursor children = query(uri, null, null, null, null);
 230             if (children != null && children.moveToFirst())  {
 231                 long childId;
 232                 boolean isDir;
 233                 //String remotePath;
 234                 while (!children.isAfterLast()) {
 235                     childId = children.getLong(children.getColumnIndex(ProviderTableMeta._ID));
 236                     isDir = "DIR".equals(children.getString(children.getColumnIndex(ProviderTableMeta.FILE_CONTENT_TYPE)));
 237                     //remotePath = children.getString(children.getColumnIndex(ProviderTableMeta.FILE_PATH));
 238                     if (isDir) {
 239                         count += delete(db, ContentUris.withAppendedId(ProviderTableMeta.CONTENT_URI_DIR, childId), null, null);
 240                     } else {
 241                         count += delete(db, ContentUris.withAppendedId(ProviderTableMeta.CONTENT_URI_FILE, childId), null, null);
 242                     }
 243                     children.moveToNext();
 244                 }
 245                 children.close();
 246             } /*else {
 247                 Log_OC.d(TAG, "No child to remove in DIRECTORY " + folderName);
 248             }
 249             Log_OC.d(TAG, "Removing DIRECTORY " + folderName + " (or maybe not) ");
 250             */
 251             count += db.delete(ProviderTableMeta.FILE_TABLE_NAME,
 252                     ProviderTableMeta._ID
 253                     + "="
 254                     + uri.getPathSegments().get(1)
 255                     + (!TextUtils.isEmpty(where) ? " AND (" + where
 256                             + ")" : ""), whereArgs);
 257             /* Just for log
 258              if (folder != null) {
 259                 folder.close();
 260             }*/
 261             break;
 262         case ROOT_DIRECTORY:
 263             //Log_OC.d(TAG, "Removing ROOT!");
 264             count = db.delete(ProviderTableMeta.FILE_TABLE_NAME, where, whereArgs);
 265             break;
 266         case SHARES:
 267             count = db.delete(ProviderTableMeta.OCSHARES_TABLE_NAME, where, whereArgs);
 268             break;
 269         default:
 270             //Log_OC.e(TAG, "Unknown uri " + uri);
 271             throw new IllegalArgumentException("Unknown uri: " + uri.toString());
 272         }
 273         return count;
 274     }
 275
 276
 277     @Override
 278     public String getType(Uri uri) {
 279         switch (mUriMatcher.match(uri)) {
 280         case ROOT_DIRECTORY:
 281             return ProviderTableMeta.CONTENT_TYPE;
 282         case SINGLE_FILE:
 283             return ProviderTableMeta.CONTENT_TYPE_ITEM;
 284         default:
 285             throw new IllegalArgumentException("Unknown Uri id."
 286                     + uri.toString());
 287         }
 288     }
 289
 290     @Override
 291     public Uri insert(Uri uri, ContentValues values) {
 292         //Log_OC.d(TAG, "Inserting " + values.getAsString(ProviderTableMeta.FILE_PATH) + " at provider " + this);
 293         Log_OC.d(TAG, "Uri " + uri);
 294         Uri newUri = null;
 295         SQLiteDatabase db = mDbHelper.getWritableDatabase();
 296         db.beginTransaction();
 297
 298         // Insert action
 299         try {
 300             newUri = insert(db, uri, values);
 301             db.setTransactionSuccessful();
 302         } finally {
 303             db.endTransaction();
 304         }
 305         getContext().getContentResolver().notifyChange(newUri, null);
 306
 307         // Get parentId to notify the change
 308         long parentId = getParentId(newUri);
 309         // Notify the change to the parent folder
 310         notifyChangeToParentUri(parentId);
 311
 312         return newUri;
 313     }
 314
 315     private Uri insert(SQLiteDatabase db, Uri uri, ContentValues values) {
 316         switch (mUriMatcher.match(uri)){
 317         case ROOT_DIRECTORY:
 318         case SINGLE_FILE:
 319             String remotePath = values.getAsString(ProviderTableMeta.FILE_PATH);
 320             String accountName = values.getAsString(ProviderTableMeta.FILE_ACCOUNT_OWNER);
 321             String[] projection = new String[] {ProviderTableMeta._ID, ProviderTableMeta.FILE_PATH, ProviderTableMeta.FILE_ACCOUNT_OWNER };
 322             String where = ProviderTableMeta.FILE_PATH + "=? AND " + ProviderTableMeta.FILE_ACCOUNT_OWNER + "=?";
 323             String[] whereArgs = new String[] {remotePath, accountName};
 324             Cursor doubleCheck = query(db, uri, projection, where, whereArgs, null);
 325             if (doubleCheck == null || !doubleCheck.moveToFirst()) {    // ugly patch; serious refactorization is needed to reduce work in FileDataStorageManager and bring it to FileContentProvider
 326                 long rowId = db.insert(ProviderTableMeta.FILE_TABLE_NAME, null, values);
 327                 if (rowId > 0) {
 328                     Uri insertedFileUri = ContentUris.withAppendedId(ProviderTableMeta.CONTENT_URI_FILE, rowId);
 329                     //Log_OC.d(TAG, "Inserted " + values.getAsString(ProviderTableMeta.FILE_PATH) + " at provider " + this);
 330                     return insertedFileUri;
 331                 } else {
 332                     //Log_OC.d(TAG, "Error while inserting " + values.getAsString(ProviderTableMeta.FILE_PATH)  + " at provider " + this);
 333                     throw new SQLException("ERROR " + uri);
 334                 }
 335             } else {
 336                 // file is already inserted; race condition, let's avoid a duplicated entry
 337                 Uri insertedFileUri = ContentUris.withAppendedId(ProviderTableMeta.CONTENT_URI_FILE, doubleCheck.getLong(doubleCheck.getColumnIndex(ProviderTableMeta._ID)));
 338                 doubleCheck.close();
 339
 340                 return insertedFileUri;
 341             }
 342
 343         case SHARES:
 344             String path = values.getAsString(ProviderTableMeta.OCSHARES_PATH);
 345             String accountNameShare= values.getAsString(ProviderTableMeta.OCSHARES_ACCOUNT_OWNER);
 346             String[] projectionShare = new String[] {ProviderTableMeta._ID, ProviderTableMeta.OCSHARES_PATH, ProviderTableMeta.OCSHARES_ACCOUNT_OWNER };
 347             String whereShare = ProviderTableMeta.OCSHARES_PATH + "=? AND " + ProviderTableMeta.OCSHARES_ACCOUNT_OWNER + "=?";
 348             String[] whereArgsShare = new String[] {path, accountNameShare};
 349             Uri insertedShareUri = null;
 350             Cursor doubleCheckShare = query(db, uri, projectionShare, whereShare, whereArgsShare, null);
 351             if (doubleCheckShare == null || !doubleCheckShare.moveToFirst()) {    // ugly patch; serious refactorization is needed to reduce work in FileDataStorageManager and bring it to FileContentProvider
 352                 long rowId = db.insert(ProviderTableMeta.OCSHARES_TABLE_NAME, null, values);
 353                 if (rowId >0) {
 354                     insertedShareUri = ContentUris.withAppendedId(ProviderTableMeta.CONTENT_URI_SHARE, rowId);
 355                 } else {
 356                     throw new SQLException("ERROR " + uri);
 357
 358                 }
 359             } else {
 360                 // file is already inserted; race condition, let's avoid a duplicated entry
 361                 insertedShareUri = ContentUris.withAppendedId(ProviderTableMeta.CONTENT_URI_SHARE, doubleCheckShare.getLong(doubleCheckShare.getColumnIndex(ProviderTableMeta._ID)));
 362                 doubleCheckShare.close();
 363             }
 364             updateFilesTableAccordingToShareInsertion(db, uri, values);
 365             return insertedShareUri;
 366
 367
 368         default:
 369             throw new IllegalArgumentException("Unknown uri id: " + uri);
 370         }
 371
 372     }
 373
 374     private void updateFilesTableAccordingToShareInsertion(SQLiteDatabase db, Uri uri, ContentValues shareValues) {
 375         ContentValues fileValues = new ContentValues();
 376         fileValues.put(ProviderTableMeta.FILE_SHARE_BY_LINK,
 377                             ShareType.PUBLIC_LINK.getValue() == shareValues.getAsInteger(ProviderTableMeta.OCSHARES_SHARE_TYPE)? 1 : 0);
 378         String whereShare = ProviderTableMeta.FILE_PATH + "=? AND " + ProviderTableMeta.FILE_ACCOUNT_OWNER + "=?";
 379         String[] whereArgsShare = new String[] {
 380                 shareValues.getAsString(ProviderTableMeta.OCSHARES_PATH),
 381                 shareValues.getAsString(ProviderTableMeta.OCSHARES_ACCOUNT_OWNER)
 382         };
 383         db.update(ProviderTableMeta.FILE_TABLE_NAME, fileValues, whereShare, whereArgsShare);
 384     }
 385
 386
 387     @Override
 388     public boolean onCreate() {
 389         mDbHelper = new DataBaseHelper(getContext());
 390
 391         String authority = getContext().getResources().getString(R.string.authority);
 392         mUriMatcher = new UriMatcher(UriMatcher.NO_MATCH);
 393         mUriMatcher.addURI(authority, null, ROOT_DIRECTORY);
 394         mUriMatcher.addURI(authority, "file/", SINGLE_FILE);
 395         mUriMatcher.addURI(authority, "file/#", SINGLE_FILE);
 396         mUriMatcher.addURI(authority, "dir/", DIRECTORY);
 397         mUriMatcher.addURI(authority, "dir/#", DIRECTORY);
 398         mUriMatcher.addURI(authority, "shares/", SHARES);
 399         mUriMatcher.addURI(authority, "shares/#", SHARES);
 400
 401         return true;
 402     }
 403
 404
 405     @Override
 406     public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder) {
 407         Cursor result = null;
 408         SQLiteDatabase db = mDbHelper.getReadableDatabase();
 409         db.beginTransaction();
 410         try {
 411             result = query(db, uri, projection, selection, selectionArgs, sortOrder);
 412             db.setTransactionSuccessful();
 413         } finally {
 414             db.endTransaction();
 415         }
 416         return result;
 417     }
 418
 419     private Cursor query(SQLiteDatabase db, Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder) {
 420         SQLiteQueryBuilder sqlQuery = new SQLiteQueryBuilder();
 421
 422         sqlQuery.setTables(ProviderTableMeta.FILE_TABLE_NAME);
 423         sqlQuery.setProjectionMap(mFileProjectionMap);
 424
 425         switch (mUriMatcher.match(uri)) {
 426         case ROOT_DIRECTORY:
 427             break;
 428         case DIRECTORY:
 429             String folderId = uri.getPathSegments().get(1);
 430             sqlQuery.appendWhere(ProviderTableMeta.FILE_PARENT + "="
 431                     + folderId);
 432             break;
 433         case SINGLE_FILE:
 434             if (uri.getPathSegments().size() > 1) {
 435                 sqlQuery.appendWhere(ProviderTableMeta._ID + "="
 436                         + uri.getPathSegments().get(1));
 437             }
 438             break;
 439         case SHARES:
 440             sqlQuery.setTables(ProviderTableMeta.OCSHARES_TABLE_NAME);
 441             sqlQuery.setProjectionMap(mOCSharesProjectionMap);
 442             if (uri.getPathSegments().size() > 1) {
 443                 sqlQuery.appendWhere(ProviderTableMeta._ID + "="
 444                         + uri.getPathSegments().get(1));
 445             }
 446             break;
 447         default:
 448             throw new IllegalArgumentException("Unknown uri id: " + uri);
 449         }
 450
 451         String order;
 452         if (TextUtils.isEmpty(sortOrder)) {
 453             if (mUriMatcher.match(uri) == SHARES) {
 454                 order = ProviderTableMeta.OCSHARES_DEFAULT_SORT_ORDER;
 455             } else {
 456
 457                 order = ProviderTableMeta.FILE_DEFAULT_SORT_ORDER;
 458             }
 459         } else {
 460             order = sortOrder;
 461         }
 462
 463         // DB case_sensitive
 464         db.execSQL("PRAGMA case_sensitive_like = true");
 465         Cursor c = sqlQuery.query(db, projection, selection, selectionArgs, null, null, order);
 466         Log_OC.d(TAG, "setting notification URI: " + uri);
 467         c.setNotificationUri(getContext().getContentResolver(), uri);
 468         return c;
 469     }
 470
 471     @Override
 472     public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
 473
 474         Log_OC.d(TAG, "Updating " + values.getAsString(ProviderTableMeta.FILE_PATH) + " at provider " + this);
 475         Log_OC.d(TAG, "Uri " + uri);
 476         int count = 0;
 477         SQLiteDatabase db = mDbHelper.getWritableDatabase();
 478         db.beginTransaction();
 479         try {
 480             count = update(db, uri, values, selection, selectionArgs);
 481             db.setTransactionSuccessful();
 482         } finally {
 483             db.endTransaction();
 484         }
 485         getContext().getContentResolver().notifyChange(uri, null);
 486         return count;
 487     }
 488
 489
 490
 491     private int update(SQLiteDatabase db, Uri uri, ContentValues values, String selection, String[] selectionArgs) {
 492         switch (mUriMatcher.match(uri)) {
 493             case DIRECTORY:
 494                 return  0; //updateFolderSize(db, selectionArgs[0]);
 495             case SHARES:
 496                 return db.update(ProviderTableMeta.OCSHARES_TABLE_NAME, values, selection, selectionArgs);
 497             default:
 498                 return db.update(ProviderTableMeta.FILE_TABLE_NAME, values, selection, selectionArgs);
 499         }
 500     }
 501
 502  /*
 503     private int updateFolderSize(SQLiteDatabase db, String folderId) {
 504         int count = 0;
 505         String [] whereArgs = new String[] { folderId };
 506
 507         // read current size saved for the folder
 508         long folderSize = 0;
 509         long folderParentId = -1;
 510         Uri selectFolderUri = Uri.withAppendedPath(ProviderTableMeta.CONTENT_URI_FILE, folderId);
 511         String[] folderProjection = new String[] { ProviderTableMeta.FILE_CONTENT_LENGTH,  ProviderTableMeta.FILE_PARENT};
 512         String folderWhere = ProviderTableMeta._ID + "=?";
 513         Cursor folderCursor = query(db, selectFolderUri, folderProjection, folderWhere, whereArgs, null);
 514         if (folderCursor != null && folderCursor.moveToFirst()) {
 515             folderSize = folderCursor.getLong(folderCursor.getColumnIndex(ProviderTableMeta.FILE_CONTENT_LENGTH));;
 516             folderParentId = folderCursor.getLong(folderCursor.getColumnIndex(ProviderTableMeta.FILE_PARENT));;
 517         }
 518         folderCursor.close();
 519
 520         // read and sum sizes of children
 521         long childrenSize = 0;
 522         Uri selectChildrenUri = Uri.withAppendedPath(ProviderTableMeta.CONTENT_URI_DIR, folderId);
 523         String[] childrenProjection = new String[] { ProviderTableMeta.FILE_CONTENT_LENGTH,  ProviderTableMeta.FILE_PARENT};
 524         String childrenWhere = ProviderTableMeta.FILE_PARENT + "=?";
 525         Cursor childrenCursor = query(db, selectChildrenUri, childrenProjection, childrenWhere, whereArgs, null);
 526         if (childrenCursor != null && childrenCursor.moveToFirst()) {
 527             while (!childrenCursor.isAfterLast()) {
 528                 childrenSize += childrenCursor.getLong(childrenCursor.getColumnIndex(ProviderTableMeta.FILE_CONTENT_LENGTH));
 529                 childrenCursor.moveToNext();
 530             }
 531         }
 532         childrenCursor.close();
 533
 534         // update if needed
 535         if (folderSize != childrenSize) {
 536             Log_OC.d("FileContentProvider", "Updating " + folderSize + " to " + childrenSize);
 537             ContentValues cv = new ContentValues();
 538             cv.put(ProviderTableMeta.FILE_CONTENT_LENGTH, childrenSize);
 539             count = db.update(ProviderTableMeta.FILE_TABLE_NAME, cv, folderWhere, whereArgs);
 540
 541             // propagate update until root
 542             if (folderParentId > FileDataStorageManager.ROOT_PARENT_ID) {
 543                 Log_OC.d("FileContentProvider", "Propagating update to " + folderParentId);
 544                 updateFolderSize(db, String.valueOf(folderParentId));
 545             } else {
 546                 Log_OC.d("FileContentProvider", "NOT propagating to " + folderParentId);
 547             }
 548         } else {
 549             Log_OC.d("FileContentProvider", "NOT updating, sizes are " + folderSize + " and " + childrenSize);
 550         }
 551         return count;
 552     }
 553 */
 554
 555     @Override
 556     public ContentProviderResult[] applyBatch (ArrayList<ContentProviderOperation> operations) throws OperationApplicationException {
 557         Log_OC.d("FileContentProvider", "applying batch in provider " + this + " (temporary: " + isTemporary() + ")" );
 558         ContentProviderResult[] results = new ContentProviderResult[operations.size()];
 559         int i=0;
 560
 561         SQLiteDatabase db = mDbHelper.getWritableDatabase();
 562         db.beginTransaction();  // it's supposed that transactions can be nested
 563         try {
 564             for (ContentProviderOperation operation : operations) {
 565                 results[i] = operation.apply(this, results, i);
 566                 i++;
 567             }
 568             db.setTransactionSuccessful();
 569         } finally {
 570             db.endTransaction();
 571         }
 572         Log_OC.d("FileContentProvider", "applied batch in provider " + this);
 573         return results;
 574     }
 575
 576
 577     class DataBaseHelper extends SQLiteOpenHelper {
 578
 579         public DataBaseHelper(Context context) {
 580             super(context, ProviderMeta.DB_NAME, null, ProviderMeta.DB_VERSION);
 581
 582         }
 583
 584         @Override
 585         public void onCreate(SQLiteDatabase db) {
 586             // files table
 587             Log_OC.i("SQL", "Entering in onCreate");
 588             db.execSQL("CREATE TABLE " + ProviderTableMeta.FILE_TABLE_NAME + "("
 589                     + ProviderTableMeta._ID + " INTEGER PRIMARY KEY, "
 590                     + ProviderTableMeta.FILE_NAME + " TEXT, "
 591                     + ProviderTableMeta.FILE_PATH + " TEXT, "
 592                     + ProviderTableMeta.FILE_PARENT + " INTEGER, "
 593                     + ProviderTableMeta.FILE_CREATION + " INTEGER, "
 594                     + ProviderTableMeta.FILE_MODIFIED + " INTEGER, "
 595                     + ProviderTableMeta.FILE_CONTENT_TYPE + " TEXT, "
 596                     + ProviderTableMeta.FILE_CONTENT_LENGTH + " INTEGER, "
 597                     + ProviderTableMeta.FILE_STORAGE_PATH + " TEXT, "
 598                     + ProviderTableMeta.FILE_ACCOUNT_OWNER + " TEXT, "
 599                     + ProviderTableMeta.FILE_LAST_SYNC_DATE + " INTEGER, "
 600                     + ProviderTableMeta.FILE_KEEP_IN_SYNC + " INTEGER, "
 601                     + ProviderTableMeta.FILE_LAST_SYNC_DATE_FOR_DATA + " INTEGER, "
 602                     + ProviderTableMeta.FILE_MODIFIED_AT_LAST_SYNC_FOR_DATA + " INTEGER, "
 603                     + ProviderTableMeta.FILE_ETAG + " TEXT, "
 604                     + ProviderTableMeta.FILE_SHARE_BY_LINK + " INTEGER, "
 605                     + ProviderTableMeta.FILE_PUBLIC_LINK  + " TEXT );"
 606                     );
 607
 608             // Create table ocshares
 609             db.execSQL("CREATE TABLE " + ProviderTableMeta.OCSHARES_TABLE_NAME + "("
 610                     + ProviderTableMeta._ID + " INTEGER PRIMARY KEY, "
 611                     + ProviderTableMeta.OCSHARES_FILE_SOURCE + " INTEGER, "
 612                     + ProviderTableMeta.OCSHARES_ITEM_SOURCE + " INTEGER, "
 613                     + ProviderTableMeta.OCSHARES_SHARE_TYPE + " INTEGER, "
 614                     + ProviderTableMeta.OCSHARES_SHARE_WITH + " TEXT, "
 615                     + ProviderTableMeta.OCSHARES_PATH + " TEXT, "
 616                     + ProviderTableMeta.OCSHARES_PERMISSIONS+ " INTEGER, "
 617                     + ProviderTableMeta.OCSHARES_SHARED_DATE + " INTEGER, "
 618                     + ProviderTableMeta.OCSHARES_EXPIRATION_DATE + " INTEGER, "
 619                     + ProviderTableMeta.OCSHARES_TOKEN + " TEXT, "
 620                     + ProviderTableMeta.OCSHARES_SHARE_WITH_DISPLAY_NAME + " TEXT, "
 621                     + ProviderTableMeta.OCSHARES_IS_DIRECTORY + " INTEGER, "  // boolean
 622                     + ProviderTableMeta.OCSHARES_USER_ID + " INTEGER, "
 623                     + ProviderTableMeta.OCSHARES_ID_REMOTE_SHARED + " INTEGER,"
 624                     + ProviderTableMeta.OCSHARES_ACCOUNT_OWNER + " TEXT );" );
 625         }
 626
 627         @Override
 628         public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
 629             Log_OC.i("SQL", "Entering in onUpgrade");
 630             boolean upgraded = false;
 631             if (oldVersion == 1 && newVersion >= 2) {
 632                 Log_OC.i("SQL", "Entering in the #1 ADD in onUpgrade");
 633                 db.execSQL("ALTER TABLE " + ProviderTableMeta.FILE_TABLE_NAME +
 634                            " ADD COLUMN " + ProviderTableMeta.FILE_KEEP_IN_SYNC  + " INTEGER " +
 635                            " DEFAULT 0");
 636                 upgraded = true;
 637             }
 638             if (oldVersion < 3 && newVersion >= 3) {
 639                 Log_OC.i("SQL", "Entering in the #2 ADD in onUpgrade");
 640                 db.beginTransaction();
 641                 try {
 642                     db.execSQL("ALTER TABLE " + ProviderTableMeta.FILE_TABLE_NAME +
 643                                " ADD COLUMN " + ProviderTableMeta.FILE_LAST_SYNC_DATE_FOR_DATA  + " INTEGER " +
 644                                " DEFAULT 0");
 645
 646                     // assume there are not local changes pending to upload
 647                     db.execSQL("UPDATE " + ProviderTableMeta.FILE_TABLE_NAME +
 648                             " SET " + ProviderTableMeta.FILE_LAST_SYNC_DATE_FOR_DATA + " = " + System.currentTimeMillis() +
 649                             " WHERE " + ProviderTableMeta.FILE_STORAGE_PATH + " IS NOT NULL");
 650
 651                     upgraded = true;
 652                     db.setTransactionSuccessful();
 653                 } finally {
 654                     db.endTransaction();
 655                 }
 656             }
 657             if (oldVersion < 4 && newVersion >= 4) {
 658                 Log_OC.i("SQL", "Entering in the #3 ADD in onUpgrade");
 659                 db.beginTransaction();
 660                 try {
 661                     db .execSQL("ALTER TABLE " + ProviderTableMeta.FILE_TABLE_NAME +
 662                            " ADD COLUMN " + ProviderTableMeta.FILE_MODIFIED_AT_LAST_SYNC_FOR_DATA  + " INTEGER " +
 663                            " DEFAULT 0");
 664
 665                     db.execSQL("UPDATE " + ProviderTableMeta.FILE_TABLE_NAME +
 666                            " SET " + ProviderTableMeta.FILE_MODIFIED_AT_LAST_SYNC_FOR_DATA + " = " + ProviderTableMeta.FILE_MODIFIED +
 667                            " WHERE " + ProviderTableMeta.FILE_STORAGE_PATH + " IS NOT NULL");
 668
 669                     upgraded = true;
 670                     db.setTransactionSuccessful();
 671                 } finally {
 672                     db.endTransaction();
 673                 }
 674             }
 675             if (!upgraded)
 676                 Log_OC.i("SQL", "OUT of the ADD in onUpgrade; oldVersion == " + oldVersion + ", newVersion == " + newVersion);
 677
 678             if (oldVersion < 5 && newVersion >= 5) {
 679                 Log_OC.i("SQL", "Entering in the #4 ADD in onUpgrade");
 680                 db.beginTransaction();
 681                 try {
 682                     db .execSQL("ALTER TABLE " + ProviderTableMeta.FILE_TABLE_NAME +
 683                             " ADD COLUMN " + ProviderTableMeta.FILE_ETAG + " TEXT " +
 684                             " DEFAULT NULL");
 685
 686                     upgraded = true;
 687                     db.setTransactionSuccessful();
 688                 } finally {
 689                     db.endTransaction();
 690                 }
 691             }
 692             if (!upgraded)
 693                 Log_OC.i("SQL", "OUT of the ADD in onUpgrade; oldVersion == " + oldVersion + ", newVersion == " + newVersion);
 694
 695             if (oldVersion < 6 && newVersion >= 6) {
 696                 Log_OC.i("SQL", "Entering in the #5 ADD in onUpgrade");
 697                 db.beginTransaction();
 698                 try {
 699                     db .execSQL("ALTER TABLE " + ProviderTableMeta.FILE_TABLE_NAME +
 700                             " ADD COLUMN " + ProviderTableMeta.FILE_SHARE_BY_LINK + " INTEGER " +
 701                             " DEFAULT 0");
 702
 703                     db .execSQL("ALTER TABLE " + ProviderTableMeta.FILE_TABLE_NAME +
 704                             " ADD COLUMN " + ProviderTableMeta.FILE_PUBLIC_LINK + " TEXT " +
 705                             " DEFAULT NULL");
 706
 707                     // Create table ocshares
 708                     db.execSQL("CREATE TABLE " + ProviderTableMeta.OCSHARES_TABLE_NAME + "("
 709                             + ProviderTableMeta._ID + " INTEGER PRIMARY KEY, "
 710                             + ProviderTableMeta.OCSHARES_FILE_SOURCE + " INTEGER, "
 711                             + ProviderTableMeta.OCSHARES_ITEM_SOURCE + " INTEGER, "
 712                             + ProviderTableMeta.OCSHARES_SHARE_TYPE + " INTEGER, "
 713                             + ProviderTableMeta.OCSHARES_SHARE_WITH + " TEXT, "
 714                             + ProviderTableMeta.OCSHARES_PATH + " TEXT, "
 715                             + ProviderTableMeta.OCSHARES_PERMISSIONS+ " INTEGER, "
 716                             + ProviderTableMeta.OCSHARES_SHARED_DATE + " INTEGER, "
 717                             + ProviderTableMeta.OCSHARES_EXPIRATION_DATE + " INTEGER, "
 718                             + ProviderTableMeta.OCSHARES_TOKEN + " TEXT, "
 719                             + ProviderTableMeta.OCSHARES_SHARE_WITH_DISPLAY_NAME + " TEXT, "
 720                             + ProviderTableMeta.OCSHARES_IS_DIRECTORY + " INTEGER, "  // boolean
 721                             + ProviderTableMeta.OCSHARES_USER_ID + " INTEGER, "
 722                             + ProviderTableMeta.OCSHARES_ID_REMOTE_SHARED + " INTEGER,"
 723                             + ProviderTableMeta.OCSHARES_ACCOUNT_OWNER + " TEXT );" );
 724
 725                     upgraded = true;
 726                     db.setTransactionSuccessful();
 727                 } finally {
 728                     db.endTransaction();
 729                 }
 730             }
 731             if (!upgraded)
 732                 Log_OC.i("SQL", "OUT of the ADD in onUpgrade; oldVersion == " + oldVersion + ", newVersion == " + newVersion);
 733         }
 734     }
 735
 736 }