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.datamodel.FileDataStorageManager;
  26 import com.owncloud.android.db.ProviderMeta;
  27 import com.owncloud.android.db.ProviderMeta.ProviderTableMeta;
  28 import com.owncloud.android.lib.operations.common.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     // Projection for ocshares table
 105     private static HashMap<String, String> mOCSharesProjectionMap;
 106     static {
 107         mOCSharesProjectionMap = new HashMap<String, String>();
 108         mOCSharesProjectionMap.put(ProviderTableMeta._ID, ProviderTableMeta._ID);
 109         mOCSharesProjectionMap.put(ProviderTableMeta.OCSHARES_FILE_SOURCE,
 110                 ProviderTableMeta.OCSHARES_FILE_SOURCE);
 111         mOCSharesProjectionMap.put(ProviderTableMeta.OCSHARES_ITEM_SOURCE,
 112                 ProviderTableMeta.OCSHARES_ITEM_SOURCE);
 113         mOCSharesProjectionMap.put(ProviderTableMeta.OCSHARES_SHARE_TYPE,
 114                 ProviderTableMeta.OCSHARES_SHARE_TYPE);
 115         mOCSharesProjectionMap.put(ProviderTableMeta.OCSHARES_SHARE_WITH,
 116                 ProviderTableMeta.OCSHARES_SHARE_WITH);
 117         mOCSharesProjectionMap.put(ProviderTableMeta.OCSHARES_PATH,
 118                 ProviderTableMeta.OCSHARES_PATH);
 119         mOCSharesProjectionMap.put(ProviderTableMeta.OCSHARES_PERMISSIONS,
 120                 ProviderTableMeta.OCSHARES_PERMISSIONS);
 121         mOCSharesProjectionMap.put(ProviderTableMeta.OCSHARES_SHARED_DATE,
 122                 ProviderTableMeta.OCSHARES_SHARED_DATE);
 123         mOCSharesProjectionMap.put(ProviderTableMeta.OCSHARES_EXPIRATION_DATE,
 124                 ProviderTableMeta.OCSHARES_EXPIRATION_DATE);
 125         mOCSharesProjectionMap.put(ProviderTableMeta.OCSHARES_TOKEN,
 126                 ProviderTableMeta.OCSHARES_TOKEN);
 127         mOCSharesProjectionMap.put(ProviderTableMeta.OCSHARES_SHARE_WITH_DISPLAY_NAME,
 128                 ProviderTableMeta.OCSHARES_SHARE_WITH_DISPLAY_NAME);
 129         mOCSharesProjectionMap.put(ProviderTableMeta.OCSHARES_IS_DIRECTORY,
 130                 ProviderTableMeta.OCSHARES_IS_DIRECTORY);
 131         mOCSharesProjectionMap.put(ProviderTableMeta.OCSHARES_USER_ID,
 132                 ProviderTableMeta.OCSHARES_USER_ID);
 133         mOCSharesProjectionMap.put(ProviderTableMeta.OCSHARES_ID_REMOTE_SHARED,
 134                 ProviderTableMeta.OCSHARES_ID_REMOTE_SHARED);
 135         mOCSharesProjectionMap.put(ProviderTableMeta.OCSHARES_ACCOUNT_OWNER,
 136                 ProviderTableMeta.OCSHARES_ACCOUNT_OWNER);
 137     }
 138
 139     private UriMatcher mUriMatcher;
 140
 141     @Override
 142     public int delete(Uri uri, String where, String[] whereArgs) {
 143         //Log_OC.d(TAG, "Deleting " + uri + " at provider " + this);
 144         int count = 0;
 145         SQLiteDatabase db = mDbHelper.getWritableDatabase();
 146         db.beginTransaction();
 147         try {
 148             count = delete(db, uri, where, whereArgs);
 149             db.setTransactionSuccessful();
 150         } finally {
 151             db.endTransaction();
 152         }
 153         getContext().getContentResolver().notifyChange(uri, null);
 154         return count;
 155     }
 156
 157     private int delete(SQLiteDatabase db, Uri uri, String where, String[] whereArgs) {
 158         int count = 0;
 159         switch (mUriMatcher.match(uri)) {
 160         case SINGLE_FILE:
 161             /*Cursor c = query(db, uri, null, where, whereArgs, null);
 162             String remotePath = "(unexisting)";
 163             if (c != null && c.moveToFirst()) {
 164                 remotePath = c.getString(c.getColumnIndex(ProviderTableMeta.FILE_PATH));
 165             }
 166             Log_OC.d(TAG, "Removing FILE " + remotePath);
 167             */
 168             count = db.delete(ProviderTableMeta.FILE_TABLE_NAME,
 169                     ProviderTableMeta._ID
 170                             + "="
 171                             + uri.getPathSegments().get(1)
 172                             + (!TextUtils.isEmpty(where) ? " AND (" + where
 173                                     + ")" : ""), whereArgs);
 174             /* just for log
 175             if (c!=null) {
 176                 c.close();
 177             }
 178             */
 179             break;
 180         case DIRECTORY:
 181             // deletion of folder is recursive
 182             /*
 183             Uri folderUri = ContentUris.withAppendedId(ProviderTableMeta.CONTENT_URI_FILE, Long.parseLong(uri.getPathSegments().get(1)));
 184             Cursor folder = query(db, folderUri, null, null, null, null);
 185             String folderName = "(unknown)";
 186             if (folder != null && folder.moveToFirst()) {
 187                 folderName = folder.getString(folder.getColumnIndex(ProviderTableMeta.FILE_PATH));
 188             }
 189             */
 190             Cursor children = query(uri, null, null, null, null);
 191             if (children != null && children.moveToFirst())  {
 192                 long childId;
 193                 boolean isDir;
 194                 //String remotePath;
 195                 while (!children.isAfterLast()) {
 196                     childId = children.getLong(children.getColumnIndex(ProviderTableMeta._ID));
 197                     isDir = "DIR".equals(children.getString(children.getColumnIndex(ProviderTableMeta.FILE_CONTENT_TYPE)));
 198                     //remotePath = children.getString(children.getColumnIndex(ProviderTableMeta.FILE_PATH));
 199                     if (isDir) {
 200                         count += delete(db, ContentUris.withAppendedId(ProviderTableMeta.CONTENT_URI_DIR, childId), null, null);
 201                     } else {
 202                         count += delete(db, ContentUris.withAppendedId(ProviderTableMeta.CONTENT_URI_FILE, childId), null, null);
 203                     }
 204                     children.moveToNext();
 205                 }
 206                 children.close();
 207             } /*else {
 208                 Log_OC.d(TAG, "No child to remove in DIRECTORY " + folderName);
 209             }
 210             Log_OC.d(TAG, "Removing DIRECTORY " + folderName + " (or maybe not) ");
 211             */
 212             count += db.delete(ProviderTableMeta.FILE_TABLE_NAME,
 213                     ProviderTableMeta._ID
 214                     + "="
 215                     + uri.getPathSegments().get(1)
 216                     + (!TextUtils.isEmpty(where) ? " AND (" + where
 217                             + ")" : ""), whereArgs);
 218             /* Just for log
 219              if (folder != null) {
 220                 folder.close();
 221             }*/
 222             break;
 223         case ROOT_DIRECTORY:
 224             //Log_OC.d(TAG, "Removing ROOT!");
 225             count = db.delete(ProviderTableMeta.FILE_TABLE_NAME, where, whereArgs);
 226             break;
 227         case SHARES:
 228             count = db.delete(ProviderTableMeta.OCSHARES_TABLE_NAME, where, whereArgs);
 229             break;
 230         default:
 231             //Log_OC.e(TAG, "Unknown uri " + uri);
 232             throw new IllegalArgumentException("Unknown uri: " + uri.toString());
 233         }
 234         return count;
 235     }
 236
 237
 238     // TODO: switch(uri)
 239     @Override
 240     public String getType(Uri uri) {
 241         switch (mUriMatcher.match(uri)) {
 242         case ROOT_DIRECTORY:
 243             return ProviderTableMeta.CONTENT_TYPE;
 244         case SINGLE_FILE:
 245             return ProviderTableMeta.CONTENT_TYPE_ITEM;
 246         default:
 247             throw new IllegalArgumentException("Unknown Uri id."
 248                     + uri.toString());
 249         }
 250     }
 251
 252     @Override
 253     public Uri insert(Uri uri, ContentValues values) {
 254         //Log_OC.d(TAG, "Inserting " + values.getAsString(ProviderTableMeta.FILE_PATH) + " at provider " + this);
 255         Uri newUri = null;
 256         SQLiteDatabase db = mDbHelper.getWritableDatabase();
 257         db.beginTransaction();
 258         try {
 259             newUri = insert(db, uri, values);
 260             db.setTransactionSuccessful();
 261         } finally {
 262             db.endTransaction();
 263         }
 264         getContext().getContentResolver().notifyChange(newUri, null);
 265         return newUri;
 266     }
 267
 268     private Uri insert(SQLiteDatabase db, Uri uri, ContentValues values) {
 269         switch (mUriMatcher.match(uri)){
 270         case ROOT_DIRECTORY:
 271         case SINGLE_FILE:
 272             String remotePath = values.getAsString(ProviderTableMeta.FILE_PATH);
 273             String accountName = values.getAsString(ProviderTableMeta.FILE_ACCOUNT_OWNER);
 274             String[] projection = new String[] {ProviderTableMeta._ID, ProviderTableMeta.FILE_PATH, ProviderTableMeta.FILE_ACCOUNT_OWNER };
 275             String where = ProviderTableMeta.FILE_PATH + "=? AND " + ProviderTableMeta.FILE_ACCOUNT_OWNER + "=?";
 276             String[] whereArgs = new String[] {remotePath, accountName};
 277             Cursor doubleCheck = query(db, uri, projection, where, whereArgs, null);
 278             if (doubleCheck == null || !doubleCheck.moveToFirst()) {    // ugly patch; serious refactorization is needed to reduce work in FileDataStorageManager and bring it to FileContentProvider
 279                 long rowId = db.insert(ProviderTableMeta.FILE_TABLE_NAME, null, values);
 280                 if (rowId > 0) {
 281                     Uri insertedFileUri = ContentUris.withAppendedId(ProviderTableMeta.CONTENT_URI_FILE, rowId);
 282                     //Log_OC.d(TAG, "Inserted " + values.getAsString(ProviderTableMeta.FILE_PATH) + " at provider " + this);
 283                     return insertedFileUri;
 284                 } else {
 285                     //Log_OC.d(TAG, "Error while inserting " + values.getAsString(ProviderTableMeta.FILE_PATH)  + " at provider " + this);
 286                     throw new SQLException("ERROR " + uri);
 287                 }
 288             } else {
 289                 // file is already inserted; race condition, let's avoid a duplicated entry
 290                 Uri insertedFileUri = ContentUris.withAppendedId(ProviderTableMeta.CONTENT_URI_FILE, doubleCheck.getLong(doubleCheck.getColumnIndex(ProviderTableMeta._ID)));
 291                 doubleCheck.close();
 292
 293                 return insertedFileUri;
 294             }
 295
 296         case SHARES:
 297             String path = values.getAsString(ProviderTableMeta.OCSHARES_PATH);
 298             String accountNameShare= values.getAsString(ProviderTableMeta.OCSHARES_ACCOUNT_OWNER);
 299             String[] projectionShare = new String[] {ProviderTableMeta._ID, ProviderTableMeta.OCSHARES_PATH, ProviderTableMeta.OCSHARES_ACCOUNT_OWNER };
 300             String whereShare = ProviderTableMeta.OCSHARES_PATH + "=? AND " + ProviderTableMeta.OCSHARES_ACCOUNT_OWNER + "=?";
 301             String[] whereArgsShare = new String[] {path, accountNameShare};
 302             Uri insertedShareUri = null;
 303             Cursor doubleCheckShare = query(db, uri, projectionShare, whereShare, whereArgsShare, null);
 304             if (doubleCheckShare == null || !doubleCheckShare.moveToFirst()) {    // ugly patch; serious refactorization is needed to reduce work in FileDataStorageManager and bring it to FileContentProvider
 305                 long rowId = db.insert(ProviderTableMeta.OCSHARES_TABLE_NAME, null, values);
 306                 if (rowId >0) {
 307                     insertedShareUri = ContentUris.withAppendedId(ProviderTableMeta.CONTENT_URI_SHARE, rowId);
 308                 } else {
 309                     throw new SQLException("ERROR " + uri);
 310
 311                 }
 312             } else {
 313                 // file is already inserted; race condition, let's avoid a duplicated entry
 314                 insertedShareUri = ContentUris.withAppendedId(ProviderTableMeta.CONTENT_URI_SHARE, doubleCheckShare.getLong(doubleCheckShare.getColumnIndex(ProviderTableMeta._ID)));
 315                 doubleCheckShare.close();
 316             }
 317             updateFilesTableAccordingToShareInsertion(db, uri, values);
 318             return insertedShareUri;
 319
 320
 321         default:
 322             throw new IllegalArgumentException("Unknown uri id: " + uri);
 323         }
 324
 325     }
 326
 327     private void updateFilesTableAccordingToShareInsertion(SQLiteDatabase db, Uri uri, ContentValues shareValues) {
 328         ContentValues fileValues = new ContentValues();
 329         fileValues.put(ProviderTableMeta.FILE_SHARE_BY_LINK,
 330                             ShareType.PUBLIC_LINK.getValue() == shareValues.getAsInteger(ProviderTableMeta.OCSHARES_SHARE_TYPE)? 1 : 0);
 331         String whereShare = ProviderTableMeta.FILE_PATH + "=? AND " + ProviderTableMeta.FILE_ACCOUNT_OWNER + "=?";
 332         String[] whereArgsShare = new String[] {
 333                 shareValues.getAsString(ProviderTableMeta.OCSHARES_PATH),
 334                 shareValues.getAsString(ProviderTableMeta.OCSHARES_ACCOUNT_OWNER)
 335         };
 336         db.update(ProviderTableMeta.FILE_TABLE_NAME, fileValues, whereShare, whereArgsShare);
 337     }
 338
 339
 340     @Override
 341     public boolean onCreate() {
 342         mDbHelper = new DataBaseHelper(getContext());
 343
 344         String authority = getContext().getResources().getString(R.string.authority);
 345         mUriMatcher = new UriMatcher(UriMatcher.NO_MATCH);
 346         mUriMatcher.addURI(authority, null, ROOT_DIRECTORY);
 347         mUriMatcher.addURI(authority, "file/", SINGLE_FILE);
 348         mUriMatcher.addURI(authority, "file/#", SINGLE_FILE);
 349         mUriMatcher.addURI(authority, "dir/", DIRECTORY);
 350         mUriMatcher.addURI(authority, "dir/#", DIRECTORY);
 351         mUriMatcher.addURI(authority, "shares/", SHARES);
 352         mUriMatcher.addURI(authority, "shares/#", SHARES);
 353
 354         return true;
 355     }
 356
 357
 358     @Override
 359     public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder) {
 360         Cursor result = null;
 361         SQLiteDatabase db = mDbHelper.getReadableDatabase();
 362         db.beginTransaction();
 363         try {
 364             result = query(db, uri, projection, selection, selectionArgs, sortOrder);
 365             db.setTransactionSuccessful();
 366         } finally {
 367             db.endTransaction();
 368         }
 369         return result;
 370     }
 371
 372     private Cursor query(SQLiteDatabase db, Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder) {
 373         SQLiteQueryBuilder sqlQuery = new SQLiteQueryBuilder();
 374
 375         sqlQuery.setTables(ProviderTableMeta.FILE_TABLE_NAME);
 376         sqlQuery.setProjectionMap(mFileProjectionMap);
 377
 378         switch (mUriMatcher.match(uri)) {
 379         case ROOT_DIRECTORY:
 380             break;
 381         case DIRECTORY:
 382             String folderId = uri.getPathSegments().get(1);
 383             sqlQuery.appendWhere(ProviderTableMeta.FILE_PARENT + "="
 384                     + folderId);
 385             break;
 386         case SINGLE_FILE:
 387             if (uri.getPathSegments().size() > 1) {
 388                 sqlQuery.appendWhere(ProviderTableMeta._ID + "="
 389                         + uri.getPathSegments().get(1));
 390             }
 391             break;
 392         case SHARES:
 393             sqlQuery.setTables(ProviderTableMeta.OCSHARES_TABLE_NAME);
 394             sqlQuery.setProjectionMap(mOCSharesProjectionMap);
 395             if (uri.getPathSegments().size() > 1) {
 396                 sqlQuery.appendWhere(ProviderTableMeta._ID + "="
 397                         + uri.getPathSegments().get(1));
 398             }
 399             break;
 400         default:
 401             throw new IllegalArgumentException("Unknown uri id: " + uri);
 402         }
 403
 404         String order;
 405         if (TextUtils.isEmpty(sortOrder)) {
 406             if (mUriMatcher.match(uri) == SHARES) {
 407                 order = ProviderTableMeta.OCSHARES_DEFAULT_SORT_ORDER;
 408             } else {
 409
 410                 order = ProviderTableMeta.FILE_DEFAULT_SORT_ORDER;
 411             }
 412         } else {
 413             order = sortOrder;
 414         }
 415
 416         // DB case_sensitive
 417         db.execSQL("PRAGMA case_sensitive_like = true");
 418         Cursor c = sqlQuery.query(db, projection, selection, selectionArgs, null, null, order);
 419         c.setNotificationUri(getContext().getContentResolver(), uri);
 420         return c;
 421     }
 422
 423     @Override
 424     public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
 425
 426         //Log_OC.d(TAG, "Updating " + values.getAsString(ProviderTableMeta.FILE_PATH) + " at provider " + this);
 427         int count = 0;
 428         SQLiteDatabase db = mDbHelper.getWritableDatabase();
 429         db.beginTransaction();
 430         try {
 431             count = update(db, uri, values, selection, selectionArgs);
 432             db.setTransactionSuccessful();
 433         } finally {
 434             db.endTransaction();
 435         }
 436         getContext().getContentResolver().notifyChange(uri, null);
 437         return count;
 438     }
 439
 440
 441
 442     private int update(SQLiteDatabase db, Uri uri, ContentValues values, String selection, String[] selectionArgs) {
 443         switch (mUriMatcher.match(uri)) {
 444             case DIRECTORY:
 445                 return updateFolderSize(db, selectionArgs[0]);
 446             case SHARES:
 447                 return db.update(ProviderTableMeta.OCSHARES_TABLE_NAME, values, selection, selectionArgs);
 448             default:
 449                 return db.update(ProviderTableMeta.FILE_TABLE_NAME, values, selection, selectionArgs);
 450         }
 451     }
 452
 453
 454     private int updateFolderSize(SQLiteDatabase db, String folderId) {
 455         int count = 0;
 456         String [] whereArgs = new String[] { folderId };
 457
 458         // read current size saved for the folder
 459         long folderSize = 0;
 460         long folderParentId = -1;
 461         Uri selectFolderUri = Uri.withAppendedPath(ProviderTableMeta.CONTENT_URI_FILE, folderId);
 462         String[] folderProjection = new String[] { ProviderTableMeta.FILE_CONTENT_LENGTH,  ProviderTableMeta.FILE_PARENT};
 463         String folderWhere = ProviderTableMeta._ID + "=?";
 464         Cursor folderCursor = query(db, selectFolderUri, folderProjection, folderWhere, whereArgs, null);
 465         if (folderCursor != null && folderCursor.moveToFirst()) {
 466             folderSize = folderCursor.getLong(folderCursor.getColumnIndex(ProviderTableMeta.FILE_CONTENT_LENGTH));;
 467             folderParentId = folderCursor.getLong(folderCursor.getColumnIndex(ProviderTableMeta.FILE_PARENT));;
 468         }
 469         folderCursor.close();
 470
 471         // read and sum sizes of children
 472         long childrenSize = 0;
 473         Uri selectChildrenUri = Uri.withAppendedPath(ProviderTableMeta.CONTENT_URI_DIR, folderId);
 474         String[] childrenProjection = new String[] { ProviderTableMeta.FILE_CONTENT_LENGTH,  ProviderTableMeta.FILE_PARENT};
 475         String childrenWhere = ProviderTableMeta.FILE_PARENT + "=?";
 476         Cursor childrenCursor = query(db, selectChildrenUri, childrenProjection, childrenWhere, whereArgs, null);
 477         if (childrenCursor != null && childrenCursor.moveToFirst()) {
 478             while (!childrenCursor.isAfterLast()) {
 479                 childrenSize += childrenCursor.getLong(childrenCursor.getColumnIndex(ProviderTableMeta.FILE_CONTENT_LENGTH));
 480                 childrenCursor.moveToNext();
 481             }
 482         }
 483         childrenCursor.close();
 484
 485         // update if needed
 486         if (folderSize != childrenSize) {
 487             Log_OC.d("FileContentProvider", "Updating " + folderSize + " to " + childrenSize);
 488             ContentValues cv = new ContentValues();
 489             cv.put(ProviderTableMeta.FILE_CONTENT_LENGTH, childrenSize);
 490             count = db.update(ProviderTableMeta.FILE_TABLE_NAME, cv, folderWhere, whereArgs);
 491
 492             // propagate update until root
 493             if (folderParentId > FileDataStorageManager.ROOT_PARENT_ID) {
 494                 Log_OC.d("FileContentProvider", "Propagating update to " + folderParentId);
 495                 updateFolderSize(db, String.valueOf(folderParentId));
 496             } else {
 497                 Log_OC.d("FileContentProvider", "NOT propagating to " + folderParentId);
 498             }
 499         } else {
 500             Log_OC.d("FileContentProvider", "NOT updating, sizes are " + folderSize + " and " + childrenSize);
 501         }
 502         return count;
 503     }
 504
 505
 506     @Override
 507     public ContentProviderResult[] applyBatch (ArrayList<ContentProviderOperation> operations) throws OperationApplicationException {
 508         Log_OC.d("FileContentProvider", "applying batch in provider " + this + " (temporary: " + isTemporary() + ")" );
 509         ContentProviderResult[] results = new ContentProviderResult[operations.size()];
 510         int i=0;
 511
 512         SQLiteDatabase db = mDbHelper.getWritableDatabase();
 513         db.beginTransaction();  // it's supposed that transactions can be nested
 514         try {
 515             for (ContentProviderOperation operation : operations) {
 516                 results[i] = operation.apply(this, results, i);
 517                 i++;
 518             }
 519             db.setTransactionSuccessful();
 520         } finally {
 521             db.endTransaction();
 522         }
 523         Log_OC.d("FileContentProvider", "applied batch in provider " + this);
 524         return results;
 525     }
 526
 527
 528     class DataBaseHelper extends SQLiteOpenHelper {
 529
 530         public DataBaseHelper(Context context) {
 531             super(context, ProviderMeta.DB_NAME, null, ProviderMeta.DB_VERSION);
 532
 533         }
 534
 535         @Override
 536         public void onCreate(SQLiteDatabase db) {
 537             // files table
 538             Log_OC.i("SQL", "Entering in onCreate");
 539             db.execSQL("CREATE TABLE " + ProviderTableMeta.FILE_TABLE_NAME + "("
 540                     + ProviderTableMeta._ID + " INTEGER PRIMARY KEY, "
 541                     + ProviderTableMeta.FILE_NAME + " TEXT, "
 542                     + ProviderTableMeta.FILE_PATH + " TEXT, "
 543                     + ProviderTableMeta.FILE_PARENT + " INTEGER, "
 544                     + ProviderTableMeta.FILE_CREATION + " INTEGER, "
 545                     + ProviderTableMeta.FILE_MODIFIED + " INTEGER, "
 546                     + ProviderTableMeta.FILE_CONTENT_TYPE + " TEXT, "
 547                     + ProviderTableMeta.FILE_CONTENT_LENGTH + " INTEGER, "
 548                     + ProviderTableMeta.FILE_STORAGE_PATH + " TEXT, "
 549                     + ProviderTableMeta.FILE_ACCOUNT_OWNER + " TEXT, "
 550                     + ProviderTableMeta.FILE_LAST_SYNC_DATE + " INTEGER, "
 551                     + ProviderTableMeta.FILE_KEEP_IN_SYNC + " INTEGER, "
 552                     + ProviderTableMeta.FILE_LAST_SYNC_DATE_FOR_DATA + " INTEGER, "
 553                     + ProviderTableMeta.FILE_MODIFIED_AT_LAST_SYNC_FOR_DATA + " INTEGER, "
 554                     + ProviderTableMeta.FILE_ETAG + " TEXT, "
 555                     + ProviderTableMeta.FILE_SHARE_BY_LINK + " INTEGER, "
 556                     + ProviderTableMeta.FILE_PUBLIC_LINK  + " TEXT );"
 557                     );
 558
 559             // Create table ocshares
 560             db.execSQL("CREATE TABLE " + ProviderTableMeta.OCSHARES_TABLE_NAME + "("
 561                     + ProviderTableMeta._ID + " INTEGER PRIMARY KEY, "
 562                     + ProviderTableMeta.OCSHARES_FILE_SOURCE + " INTEGER, "
 563                     + ProviderTableMeta.OCSHARES_ITEM_SOURCE + " INTEGER, "
 564                     + ProviderTableMeta.OCSHARES_SHARE_TYPE + " INTEGER, "
 565                     + ProviderTableMeta.OCSHARES_SHARE_WITH + " TEXT, "
 566                     + ProviderTableMeta.OCSHARES_PATH + " TEXT, "
 567                     + ProviderTableMeta.OCSHARES_PERMISSIONS+ " INTEGER, "
 568                     + ProviderTableMeta.OCSHARES_SHARED_DATE + " INTEGER, "
 569                     + ProviderTableMeta.OCSHARES_EXPIRATION_DATE + " INTEGER, "
 570                     + ProviderTableMeta.OCSHARES_TOKEN + " TEXT, "
 571                     + ProviderTableMeta.OCSHARES_SHARE_WITH_DISPLAY_NAME + " TEXT, "
 572                     + ProviderTableMeta.OCSHARES_IS_DIRECTORY + " INTEGER, "  // boolean
 573                     + ProviderTableMeta.OCSHARES_USER_ID + " INTEGER, "
 574                     + ProviderTableMeta.OCSHARES_ID_REMOTE_SHARED + " INTEGER,"
 575                     + ProviderTableMeta.OCSHARES_ACCOUNT_OWNER + " TEXT );" );
 576         }
 577
 578         @Override
 579         public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
 580             Log_OC.i("SQL", "Entering in onUpgrade");
 581             boolean upgraded = false;
 582             if (oldVersion == 1 && newVersion >= 2) {
 583                 Log_OC.i("SQL", "Entering in the #1 ADD in onUpgrade");
 584                 db.execSQL("ALTER TABLE " + ProviderTableMeta.FILE_TABLE_NAME +
 585                            " ADD COLUMN " + ProviderTableMeta.FILE_KEEP_IN_SYNC  + " INTEGER " +
 586                            " DEFAULT 0");
 587                 upgraded = true;
 588             }
 589             if (oldVersion < 3 && newVersion >= 3) {
 590                 Log_OC.i("SQL", "Entering in the #2 ADD in onUpgrade");
 591                 db.beginTransaction();
 592                 try {
 593                     db.execSQL("ALTER TABLE " + ProviderTableMeta.FILE_TABLE_NAME +
 594                                " ADD COLUMN " + ProviderTableMeta.FILE_LAST_SYNC_DATE_FOR_DATA  + " INTEGER " +
 595                                " DEFAULT 0");
 596
 597                     // assume there are not local changes pending to upload
 598                     db.execSQL("UPDATE " + ProviderTableMeta.FILE_TABLE_NAME +
 599                             " SET " + ProviderTableMeta.FILE_LAST_SYNC_DATE_FOR_DATA + " = " + System.currentTimeMillis() +
 600                             " WHERE " + ProviderTableMeta.FILE_STORAGE_PATH + " IS NOT NULL");
 601
 602                     upgraded = true;
 603                     db.setTransactionSuccessful();
 604                 } finally {
 605                     db.endTransaction();
 606                 }
 607             }
 608             if (oldVersion < 4 && newVersion >= 4) {
 609                 Log_OC.i("SQL", "Entering in the #3 ADD in onUpgrade");
 610                 db.beginTransaction();
 611                 try {
 612                     db .execSQL("ALTER TABLE " + ProviderTableMeta.FILE_TABLE_NAME +
 613                            " ADD COLUMN " + ProviderTableMeta.FILE_MODIFIED_AT_LAST_SYNC_FOR_DATA  + " INTEGER " +
 614                            " DEFAULT 0");
 615
 616                     db.execSQL("UPDATE " + ProviderTableMeta.FILE_TABLE_NAME +
 617                            " SET " + ProviderTableMeta.FILE_MODIFIED_AT_LAST_SYNC_FOR_DATA + " = " + ProviderTableMeta.FILE_MODIFIED +
 618                            " WHERE " + ProviderTableMeta.FILE_STORAGE_PATH + " IS NOT NULL");
 619
 620                     upgraded = true;
 621                     db.setTransactionSuccessful();
 622                 } finally {
 623                     db.endTransaction();
 624                 }
 625             }
 626             if (!upgraded)
 627                 Log_OC.i("SQL", "OUT of the ADD in onUpgrade; oldVersion == " + oldVersion + ", newVersion == " + newVersion);
 628
 629             if (oldVersion < 5 && newVersion >= 5) {
 630                 Log_OC.i("SQL", "Entering in the #4 ADD in onUpgrade");
 631                 db.beginTransaction();
 632                 try {
 633                     db .execSQL("ALTER TABLE " + ProviderTableMeta.FILE_TABLE_NAME +
 634                             " ADD COLUMN " + ProviderTableMeta.FILE_ETAG + " TEXT " +
 635                             " DEFAULT NULL");
 636
 637                     upgraded = true;
 638                     db.setTransactionSuccessful();
 639                 } finally {
 640                     db.endTransaction();
 641                 }
 642             }
 643             if (!upgraded)
 644                 Log_OC.i("SQL", "OUT of the ADD in onUpgrade; oldVersion == " + oldVersion + ", newVersion == " + newVersion);
 645
 646             if (oldVersion < 6 && newVersion >= 6) {
 647                 Log_OC.i("SQL", "Entering in the #5 ADD in onUpgrade");
 648                 db.beginTransaction();
 649                 try {
 650                     db .execSQL("ALTER TABLE " + ProviderTableMeta.FILE_TABLE_NAME +
 651                             " ADD COLUMN " + ProviderTableMeta.FILE_SHARE_BY_LINK + " INTEGER " +
 652                             " DEFAULT 0");
 653
 654                     db .execSQL("ALTER TABLE " + ProviderTableMeta.FILE_TABLE_NAME +
 655                             " ADD COLUMN " + ProviderTableMeta.FILE_PUBLIC_LINK + " TEXT " +
 656                             " DEFAULT NULL");
 657
 658                     // Create table ocshares
 659                     db.execSQL("CREATE TABLE " + ProviderTableMeta.OCSHARES_TABLE_NAME + "("
 660                             + ProviderTableMeta._ID + " INTEGER PRIMARY KEY, "
 661                             + ProviderTableMeta.OCSHARES_FILE_SOURCE + " INTEGER, "
 662                             + ProviderTableMeta.OCSHARES_ITEM_SOURCE + " INTEGER, "
 663                             + ProviderTableMeta.OCSHARES_SHARE_TYPE + " INTEGER, "
 664                             + ProviderTableMeta.OCSHARES_SHARE_WITH + " TEXT, "
 665                             + ProviderTableMeta.OCSHARES_PATH + " TEXT, "
 666                             + ProviderTableMeta.OCSHARES_PERMISSIONS+ " INTEGER, "
 667                             + ProviderTableMeta.OCSHARES_SHARED_DATE + " INTEGER, "
 668                             + ProviderTableMeta.OCSHARES_EXPIRATION_DATE + " INTEGER, "
 669                             + ProviderTableMeta.OCSHARES_TOKEN + " TEXT, "
 670                             + ProviderTableMeta.OCSHARES_SHARE_WITH_DISPLAY_NAME + " TEXT, "
 671                             + ProviderTableMeta.OCSHARES_IS_DIRECTORY + " INTEGER, "  // boolean
 672                             + ProviderTableMeta.OCSHARES_USER_ID + " INTEGER, "
 673                             + ProviderTableMeta.OCSHARES_ID_REMOTE_SHARED + " INTEGER,"
 674                             + ProviderTableMeta.OCSHARES_ACCOUNT_OWNER + " TEXT );" );
 675
 676                     upgraded = true;
 677                     db.setTransactionSuccessful();
 678                 } finally {
 679                     db.endTransaction();
 680                 }
 681             }
 682             if (!upgraded)
 683                 Log_OC.i("SQL", "OUT of the ADD in onUpgrade; oldVersion == " + oldVersion + ", newVersion == " + newVersion);
 684         }
 685     }
 686
 687 }