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