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