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.utils.Log_OC;
  29
  30
  31
  32 import android.content.ContentProvider;
  33 import android.content.ContentProviderOperation;
  34 import android.content.ContentProviderResult;
  35 import android.content.ContentUris;
  36 import android.content.ContentValues;
  37 import android.content.Context;
  38 import android.content.OperationApplicationException;
  39 import android.content.UriMatcher;
  40 import android.database.Cursor;
  41 import android.database.SQLException;
  42 import android.database.sqlite.SQLiteDatabase;
  43 import android.database.sqlite.SQLiteOpenHelper;
  44 import android.database.sqlite.SQLiteQueryBuilder;
  45 import android.net.Uri;
  46 import android.text.TextUtils;
  47
  48 /**
  49  * The ContentProvider for the ownCloud App.
  50  *
  51  * @author Bartek Przybylski
  52  * @author David A. Velasco
  53  *
  54  */
  55 public class FileContentProvider extends ContentProvider {
  56
  57     private DataBaseHelper mDbHelper;
  58
  59     private static HashMap<String, String> mProjectionMap;
  60     static {
  61         mProjectionMap = new HashMap<String, String>();
  62         mProjectionMap.put(ProviderTableMeta._ID, ProviderTableMeta._ID);
  63         mProjectionMap.put(ProviderTableMeta.FILE_PARENT,
  64                 ProviderTableMeta.FILE_PARENT);
  65         mProjectionMap.put(ProviderTableMeta.FILE_PATH,
  66                 ProviderTableMeta.FILE_PATH);
  67         mProjectionMap.put(ProviderTableMeta.FILE_NAME,
  68                 ProviderTableMeta.FILE_NAME);
  69         mProjectionMap.put(ProviderTableMeta.FILE_CREATION,
  70                 ProviderTableMeta.FILE_CREATION);
  71         mProjectionMap.put(ProviderTableMeta.FILE_MODIFIED,
  72                 ProviderTableMeta.FILE_MODIFIED);
  73         mProjectionMap.put(ProviderTableMeta.FILE_MODIFIED_AT_LAST_SYNC_FOR_DATA,
  74                 ProviderTableMeta.FILE_MODIFIED_AT_LAST_SYNC_FOR_DATA);
  75         mProjectionMap.put(ProviderTableMeta.FILE_CONTENT_LENGTH,
  76                 ProviderTableMeta.FILE_CONTENT_LENGTH);
  77         mProjectionMap.put(ProviderTableMeta.FILE_CONTENT_TYPE,
  78                 ProviderTableMeta.FILE_CONTENT_TYPE);
  79         mProjectionMap.put(ProviderTableMeta.FILE_STORAGE_PATH,
  80                 ProviderTableMeta.FILE_STORAGE_PATH);
  81         mProjectionMap.put(ProviderTableMeta.FILE_LAST_SYNC_DATE,
  82                 ProviderTableMeta.FILE_LAST_SYNC_DATE);
  83         mProjectionMap.put(ProviderTableMeta.FILE_LAST_SYNC_DATE_FOR_DATA,
  84                 ProviderTableMeta.FILE_LAST_SYNC_DATE_FOR_DATA);
  85         mProjectionMap.put(ProviderTableMeta.FILE_KEEP_IN_SYNC,
  86                 ProviderTableMeta.FILE_KEEP_IN_SYNC);
  87         mProjectionMap.put(ProviderTableMeta.FILE_ACCOUNT_OWNER,
  88                 ProviderTableMeta.FILE_ACCOUNT_OWNER);
  89         mProjectionMap.put(ProviderTableMeta.FILE_ETAG,
  90                 ProviderTableMeta.FILE_ETAG);
  91         mProjectionMap.put(ProviderTableMeta.FILE_SHARE_BY_LINK,
  92                 ProviderTableMeta.FILE_PUBLIC_LINK);
  93     }
  94
  95     private static final int SINGLE_FILE = 1;
  96     private static final int DIRECTORY = 2;
  97     private static final int ROOT_DIRECTORY = 3;
  98
  99     private UriMatcher mUriMatcher;
 100
 101     @Override
 102     public int delete(Uri uri, String where, String[] whereArgs) {
 103         //Log_OC.d(TAG, "Deleting " + uri + " at provider " + this);
 104         int count = 0;
 105         SQLiteDatabase db = mDbHelper.getWritableDatabase();
 106         db.beginTransaction();
 107         try {
 108             count = delete(db, uri, where, whereArgs);
 109             db.setTransactionSuccessful();
 110         } finally {
 111             db.endTransaction();
 112         }
 113         getContext().getContentResolver().notifyChange(uri, null);
 114         return count;
 115     }
 116
 117
 118     private int delete(SQLiteDatabase db, Uri uri, String where, String[] whereArgs) {
 119         int count = 0;
 120         switch (mUriMatcher.match(uri)) {
 121         case SINGLE_FILE:
 122             /*Cursor c = query(db, uri, null, where, whereArgs, null);
 123             String remotePath = "(unexisting)";
 124             if (c != null && c.moveToFirst()) {
 125                 remotePath = c.getString(c.getColumnIndex(ProviderTableMeta.FILE_PATH));
 126             }
 127             Log_OC.d(TAG, "Removing FILE " + remotePath);
 128             */
 129             count = db.delete(ProviderTableMeta.DB_NAME,
 130                     ProviderTableMeta._ID
 131                             + "="
 132                             + uri.getPathSegments().get(1)
 133                             + (!TextUtils.isEmpty(where) ? " AND (" + where
 134                                     + ")" : ""), whereArgs);
 135             /* just for log
 136             if (c!=null) {
 137                 c.close();
 138             }
 139             */
 140             break;
 141         case DIRECTORY:
 142             // deletion of folder is recursive
 143             /*
 144             Uri folderUri = ContentUris.withAppendedId(ProviderTableMeta.CONTENT_URI_FILE, Long.parseLong(uri.getPathSegments().get(1)));
 145             Cursor folder = query(db, folderUri, null, null, null, null);
 146             String folderName = "(unknown)";
 147             if (folder != null && folder.moveToFirst()) {
 148                 folderName = folder.getString(folder.getColumnIndex(ProviderTableMeta.FILE_PATH));
 149             }
 150             */
 151             Cursor children = query(uri, null, null, null, null);
 152             if (children != null && children.moveToFirst())  {
 153                 long childId;
 154                 boolean isDir;
 155                 //String remotePath;
 156                 while (!children.isAfterLast()) {
 157                     childId = children.getLong(children.getColumnIndex(ProviderTableMeta._ID));
 158                     isDir = "DIR".equals(children.getString(children.getColumnIndex(ProviderTableMeta.FILE_CONTENT_TYPE)));
 159                     //remotePath = children.getString(children.getColumnIndex(ProviderTableMeta.FILE_PATH));
 160                     if (isDir) {
 161                         count += delete(db, ContentUris.withAppendedId(ProviderTableMeta.CONTENT_URI_DIR, childId), null, null);
 162                     } else {
 163                         count += delete(db, ContentUris.withAppendedId(ProviderTableMeta.CONTENT_URI_FILE, childId), null, null);
 164                     }
 165                     children.moveToNext();
 166                 }
 167                 children.close();
 168             } /*else {
 169                 Log_OC.d(TAG, "No child to remove in DIRECTORY " + folderName);
 170             }
 171             Log_OC.d(TAG, "Removing DIRECTORY " + folderName + " (or maybe not) ");
 172             */
 173             count += db.delete(ProviderTableMeta.DB_NAME,
 174                     ProviderTableMeta._ID
 175                     + "="
 176                     + uri.getPathSegments().get(1)
 177                     + (!TextUtils.isEmpty(where) ? " AND (" + where
 178                             + ")" : ""), whereArgs);
 179             /* Just for log
 180              if (folder != null) {
 181                 folder.close();
 182             }*/
 183             break;
 184         case ROOT_DIRECTORY:
 185             //Log_OC.d(TAG, "Removing ROOT!");
 186             count = db.delete(ProviderTableMeta.DB_NAME, where, whereArgs);
 187             break;
 188         default:
 189             //Log_OC.e(TAG, "Unknown uri " + uri);
 190             throw new IllegalArgumentException("Unknown uri: " + uri.toString());
 191         }
 192         return count;
 193     }
 194
 195
 196     @Override
 197     public String getType(Uri uri) {
 198         switch (mUriMatcher.match(uri)) {
 199         case ROOT_DIRECTORY:
 200             return ProviderTableMeta.CONTENT_TYPE;
 201         case SINGLE_FILE:
 202             return ProviderTableMeta.CONTENT_TYPE_ITEM;
 203         default:
 204             throw new IllegalArgumentException("Unknown Uri id."
 205                     + uri.toString());
 206         }
 207     }
 208
 209     @Override
 210     public Uri insert(Uri uri, ContentValues values) {
 211         //Log_OC.d(TAG, "Inserting " + values.getAsString(ProviderTableMeta.FILE_PATH) + " at provider " + this);
 212         Uri newUri = null;
 213         SQLiteDatabase db = mDbHelper.getWritableDatabase();
 214         db.beginTransaction();
 215         try {
 216             newUri = insert(db, uri, values);
 217             db.setTransactionSuccessful();
 218         } finally {
 219             db.endTransaction();
 220         }
 221         getContext().getContentResolver().notifyChange(newUri, null);
 222         return newUri;
 223     }
 224
 225     private Uri insert(SQLiteDatabase db, Uri uri, ContentValues values) {
 226         if (mUriMatcher.match(uri) != SINGLE_FILE &&
 227                 mUriMatcher.match(uri) != ROOT_DIRECTORY) {
 228             //Log_OC.e(TAG, "Inserting invalid URI: " + uri);
 229             throw new IllegalArgumentException("Unknown uri id: " + uri);
 230         }
 231
 232         String remotePath = values.getAsString(ProviderTableMeta.FILE_PATH);
 233         String accountName = values.getAsString(ProviderTableMeta.FILE_ACCOUNT_OWNER);
 234         String[] projection = new String[] {ProviderTableMeta._ID, ProviderTableMeta.FILE_PATH, ProviderTableMeta.FILE_ACCOUNT_OWNER };
 235         String where = ProviderTableMeta.FILE_PATH + "=? AND " + ProviderTableMeta.FILE_ACCOUNT_OWNER + "=?";
 236         String[] whereArgs = new String[] {remotePath, accountName};
 237         Cursor doubleCheck = query(db, uri, projection, where, whereArgs, null);
 238         if (doubleCheck == null || !doubleCheck.moveToFirst()) {    // ugly patch; serious refactorization is needed to reduce work in FileDataStorageManager and bring it to FileContentProvider
 239             long rowId = db.insert(ProviderTableMeta.DB_NAME, null, values);
 240             if (rowId > 0) {
 241                 Uri insertedFileUri = ContentUris.withAppendedId(ProviderTableMeta.CONTENT_URI_FILE, rowId);
 242                 //Log_OC.d(TAG, "Inserted " + values.getAsString(ProviderTableMeta.FILE_PATH) + " at provider " + this);
 243                 return insertedFileUri;
 244             } else {
 245                 //Log_OC.d(TAG, "Error while inserting " + values.getAsString(ProviderTableMeta.FILE_PATH)  + " at provider " + this);
 246                 throw new SQLException("ERROR " + uri);
 247             }
 248         } else {
 249             // file is already inserted; race condition, let's avoid a duplicated entry
 250             Uri insertedFileUri = ContentUris.withAppendedId(ProviderTableMeta.CONTENT_URI_FILE, doubleCheck.getLong(doubleCheck.getColumnIndex(ProviderTableMeta._ID)));
 251             doubleCheck.close();
 252             return insertedFileUri;
 253         }
 254     }
 255
 256
 257     @Override
 258     public boolean onCreate() {
 259         mDbHelper = new DataBaseHelper(getContext());
 260
 261         String authority = getContext().getResources().getString(R.string.authority);
 262         mUriMatcher = new UriMatcher(UriMatcher.NO_MATCH);
 263         mUriMatcher.addURI(authority, null, ROOT_DIRECTORY);
 264         mUriMatcher.addURI(authority, "file/", SINGLE_FILE);
 265         mUriMatcher.addURI(authority, "file/#", SINGLE_FILE);
 266         mUriMatcher.addURI(authority, "dir/", DIRECTORY);
 267         mUriMatcher.addURI(authority, "dir/#", DIRECTORY);
 268
 269         return true;
 270     }
 271
 272
 273     @Override
 274     public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder) {
 275         Cursor result = null;
 276         SQLiteDatabase db = mDbHelper.getReadableDatabase();
 277         db.beginTransaction();
 278         try {
 279             result = query(db, uri, projection, selection, selectionArgs, sortOrder);
 280             db.setTransactionSuccessful();
 281         } finally {
 282             db.endTransaction();
 283         }
 284         return result;
 285     }
 286
 287     private Cursor query(SQLiteDatabase db, Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder) {
 288         SQLiteQueryBuilder sqlQuery = new SQLiteQueryBuilder();
 289
 290         sqlQuery.setTables(ProviderTableMeta.DB_NAME);
 291         sqlQuery.setProjectionMap(mProjectionMap);
 292
 293         switch (mUriMatcher.match(uri)) {
 294         case ROOT_DIRECTORY:
 295             break;
 296         case DIRECTORY:
 297             String folderId = uri.getPathSegments().get(1);
 298             sqlQuery.appendWhere(ProviderTableMeta.FILE_PARENT + "="
 299                     + folderId);
 300             break;
 301         case SINGLE_FILE:
 302             if (uri.getPathSegments().size() > 1) {
 303                 sqlQuery.appendWhere(ProviderTableMeta._ID + "="
 304                         + uri.getPathSegments().get(1));
 305             }
 306             break;
 307         default:
 308             throw new IllegalArgumentException("Unknown uri id: " + uri);
 309         }
 310
 311         String order;
 312         if (TextUtils.isEmpty(sortOrder)) {
 313             order = ProviderTableMeta.DEFAULT_SORT_ORDER;
 314         } else {
 315             order = sortOrder;
 316         }
 317
 318         // DB case_sensitive
 319         db.execSQL("PRAGMA case_sensitive_like = true");
 320         Cursor c = sqlQuery.query(db, projection, selection, selectionArgs, null, null, order);
 321         c.setNotificationUri(getContext().getContentResolver(), uri);
 322         return c;
 323     }
 324
 325     @Override
 326     public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
 327
 328         //Log_OC.d(TAG, "Updating " + values.getAsString(ProviderTableMeta.FILE_PATH) + " at provider " + this);
 329         int count = 0;
 330         SQLiteDatabase db = mDbHelper.getWritableDatabase();
 331         db.beginTransaction();
 332         try {
 333             count = update(db, uri, values, selection, selectionArgs);
 334             db.setTransactionSuccessful();
 335         } finally {
 336             db.endTransaction();
 337         }
 338         getContext().getContentResolver().notifyChange(uri, null);
 339         return count;
 340     }
 341
 342
 343     private int update(SQLiteDatabase db, Uri uri, ContentValues values, String selection, String[] selectionArgs) {
 344         switch (mUriMatcher.match(uri)) {
 345             case DIRECTORY:
 346                 return updateFolderSize(db, selectionArgs[0]);
 347             default:
 348                 return db.update(ProviderTableMeta.DB_NAME, values, selection, selectionArgs);
 349         }
 350     }
 351
 352
 353     private int updateFolderSize(SQLiteDatabase db, String folderId) {
 354         int count = 0;
 355         String [] whereArgs = new String[] { folderId };
 356
 357         // read current size saved for the folder
 358         long folderSize = 0;
 359         long folderParentId = -1;
 360         Uri selectFolderUri = Uri.withAppendedPath(ProviderTableMeta.CONTENT_URI_FILE, folderId);
 361         String[] folderProjection = new String[] { ProviderTableMeta.FILE_CONTENT_LENGTH,  ProviderTableMeta.FILE_PARENT};
 362         String folderWhere = ProviderTableMeta._ID + "=?";
 363         Cursor folderCursor = query(db, selectFolderUri, folderProjection, folderWhere, whereArgs, null);
 364         if (folderCursor != null && folderCursor.moveToFirst()) {
 365             folderSize = folderCursor.getLong(folderCursor.getColumnIndex(ProviderTableMeta.FILE_CONTENT_LENGTH));;
 366             folderParentId = folderCursor.getLong(folderCursor.getColumnIndex(ProviderTableMeta.FILE_PARENT));;
 367         }
 368         folderCursor.close();
 369
 370         // read and sum sizes of children
 371         long childrenSize = 0;
 372         Uri selectChildrenUri = Uri.withAppendedPath(ProviderTableMeta.CONTENT_URI_DIR, folderId);
 373         String[] childrenProjection = new String[] { ProviderTableMeta.FILE_CONTENT_LENGTH,  ProviderTableMeta.FILE_PARENT};
 374         String childrenWhere = ProviderTableMeta.FILE_PARENT + "=?";
 375         Cursor childrenCursor = query(db, selectChildrenUri, childrenProjection, childrenWhere, whereArgs, null);
 376         if (childrenCursor != null && childrenCursor.moveToFirst()) {
 377             while (!childrenCursor.isAfterLast()) {
 378                 childrenSize += childrenCursor.getLong(childrenCursor.getColumnIndex(ProviderTableMeta.FILE_CONTENT_LENGTH));
 379                 childrenCursor.moveToNext();
 380             }
 381         }
 382         childrenCursor.close();
 383
 384         // update if needed
 385         if (folderSize != childrenSize) {
 386             Log_OC.d("FileContentProvider", "Updating " + folderSize + " to " + childrenSize);
 387             ContentValues cv = new ContentValues();
 388             cv.put(ProviderTableMeta.FILE_CONTENT_LENGTH, childrenSize);
 389             count = db.update(ProviderTableMeta.DB_NAME, cv, folderWhere, whereArgs);
 390
 391             // propagate update until root
 392             if (folderParentId > FileDataStorageManager.ROOT_PARENT_ID) {
 393                 Log_OC.d("FileContentProvider", "Propagating update to " + folderParentId);
 394                 updateFolderSize(db, String.valueOf(folderParentId));
 395             } else {
 396                 Log_OC.d("FileContentProvider", "NOT propagating to " + folderParentId);
 397             }
 398         } else {
 399             Log_OC.d("FileContentProvider", "NOT updating, sizes are " + folderSize + " and " + childrenSize);
 400         }
 401         return count;
 402     }
 403
 404
 405     @Override
 406     public ContentProviderResult[] applyBatch (ArrayList<ContentProviderOperation> operations) throws OperationApplicationException {
 407         Log_OC.d("FileContentProvider", "applying batch in provider " + this + " (temporary: " + isTemporary() + ")" );
 408         ContentProviderResult[] results = new ContentProviderResult[operations.size()];
 409         int i=0;
 410
 411         SQLiteDatabase db = mDbHelper.getWritableDatabase();
 412         db.beginTransaction();  // it's supposed that transactions can be nested
 413         try {
 414             for (ContentProviderOperation operation : operations) {
 415                 results[i] = operation.apply(this, results, i);
 416                 i++;
 417             }
 418             db.setTransactionSuccessful();
 419         } finally {
 420             db.endTransaction();
 421         }
 422         Log_OC.d("FileContentProvider", "applied batch in provider " + this);
 423         return results;
 424     }
 425
 426
 427     class DataBaseHelper extends SQLiteOpenHelper {
 428
 429         public DataBaseHelper(Context context) {
 430             super(context, ProviderMeta.DB_NAME, null, ProviderMeta.DB_VERSION);
 431
 432         }
 433
 434         @Override
 435         public void onCreate(SQLiteDatabase db) {
 436             // files table
 437             Log_OC.i("SQL", "Entering in onCreate");
 438             db.execSQL("CREATE TABLE " + ProviderTableMeta.DB_NAME + "("
 439                     + ProviderTableMeta._ID + " INTEGER PRIMARY KEY, "
 440                     + ProviderTableMeta.FILE_NAME + " TEXT, "
 441                     + ProviderTableMeta.FILE_PATH + " TEXT, "
 442                     + ProviderTableMeta.FILE_PARENT + " INTEGER, "
 443                     + ProviderTableMeta.FILE_CREATION + " INTEGER, "
 444                     + ProviderTableMeta.FILE_MODIFIED + " INTEGER, "
 445                     + ProviderTableMeta.FILE_CONTENT_TYPE + " TEXT, "
 446                     + ProviderTableMeta.FILE_CONTENT_LENGTH + " INTEGER, "
 447                     + ProviderTableMeta.FILE_STORAGE_PATH + " TEXT, "
 448                     + ProviderTableMeta.FILE_ACCOUNT_OWNER + " TEXT, "
 449                     + ProviderTableMeta.FILE_LAST_SYNC_DATE + " INTEGER, "
 450                     + ProviderTableMeta.FILE_KEEP_IN_SYNC + " INTEGER, "
 451                     + ProviderTableMeta.FILE_LAST_SYNC_DATE_FOR_DATA + " INTEGER, "
 452                     + ProviderTableMeta.FILE_MODIFIED_AT_LAST_SYNC_FOR_DATA + " INTEGER, "
 453                     + ProviderTableMeta.FILE_ETAG + " TEXT, "
 454                     + ProviderTableMeta.FILE_SHARE_BY_LINK + " INTEGER, "
 455                     + ProviderTableMeta.FILE_PUBLIC_LINK  + " TEXT );"
 456                     );
 457         }
 458
 459         @Override
 460         public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
 461             Log_OC.i("SQL", "Entering in onUpgrade");
 462             boolean upgraded = false;
 463             if (oldVersion == 1 && newVersion >= 2) {
 464                 Log_OC.i("SQL", "Entering in the #1 ADD in onUpgrade");
 465                 db.execSQL("ALTER TABLE " + ProviderTableMeta.DB_NAME +
 466                            " ADD COLUMN " + ProviderTableMeta.FILE_KEEP_IN_SYNC  + " INTEGER " +
 467                            " DEFAULT 0");
 468                 upgraded = true;
 469             }
 470             if (oldVersion < 3 && newVersion >= 3) {
 471                 Log_OC.i("SQL", "Entering in the #2 ADD in onUpgrade");
 472                 db.beginTransaction();
 473                 try {
 474                     db.execSQL("ALTER TABLE " + ProviderTableMeta.DB_NAME +
 475                                " ADD COLUMN " + ProviderTableMeta.FILE_LAST_SYNC_DATE_FOR_DATA  + " INTEGER " +
 476                                " DEFAULT 0");
 477
 478                     // assume there are not local changes pending to upload
 479                     db.execSQL("UPDATE " + ProviderTableMeta.DB_NAME +
 480                             " SET " + ProviderTableMeta.FILE_LAST_SYNC_DATE_FOR_DATA + " = " + System.currentTimeMillis() +
 481                             " WHERE " + ProviderTableMeta.FILE_STORAGE_PATH + " IS NOT NULL");
 482
 483                     upgraded = true;
 484                     db.setTransactionSuccessful();
 485                 } finally {
 486                     db.endTransaction();
 487                 }
 488             }
 489             if (oldVersion < 4 && newVersion >= 4) {
 490                 Log_OC.i("SQL", "Entering in the #3 ADD in onUpgrade");
 491                 db.beginTransaction();
 492                 try {
 493                     db .execSQL("ALTER TABLE " + ProviderTableMeta.DB_NAME +
 494                            " ADD COLUMN " + ProviderTableMeta.FILE_MODIFIED_AT_LAST_SYNC_FOR_DATA  + " INTEGER " +
 495                            " DEFAULT 0");
 496
 497                     db.execSQL("UPDATE " + ProviderTableMeta.DB_NAME +
 498                            " SET " + ProviderTableMeta.FILE_MODIFIED_AT_LAST_SYNC_FOR_DATA + " = " + ProviderTableMeta.FILE_MODIFIED +
 499                            " WHERE " + ProviderTableMeta.FILE_STORAGE_PATH + " IS NOT NULL");
 500
 501                     upgraded = true;
 502                     db.setTransactionSuccessful();
 503                 } finally {
 504                     db.endTransaction();
 505                 }
 506             }
 507             if (!upgraded)
 508                 Log_OC.i("SQL", "OUT of the ADD in onUpgrade; oldVersion == " + oldVersion + ", newVersion == " + newVersion);
 509
 510             if (oldVersion < 5 && newVersion >= 5) {
 511                 Log_OC.i("SQL", "Entering in the #4 ADD in onUpgrade");
 512                 db.beginTransaction();
 513                 try {
 514                     db .execSQL("ALTER TABLE " + ProviderTableMeta.DB_NAME +
 515                             " ADD COLUMN " + ProviderTableMeta.FILE_ETAG + " TEXT " +
 516                             " DEFAULT NULL");
 517
 518                     upgraded = true;
 519                     db.setTransactionSuccessful();
 520                 } finally {
 521                     db.endTransaction();
 522                 }
 523             }
 524             if (!upgraded)
 525                 Log_OC.i("SQL", "OUT of the ADD in onUpgrade; oldVersion == " + oldVersion + ", newVersion == " + newVersion);
 526
 527             if (oldVersion < 6 && newVersion >= 6) {
 528                 Log_OC.i("SQL", "Entering in the #5 ADD in onUpgrade");
 529                 db.beginTransaction();
 530                 try {
 531                     db .execSQL("ALTER TABLE " + ProviderTableMeta.DB_NAME +
 532                             " ADD COLUMN " + ProviderTableMeta.FILE_SHARE_BY_LINK + " INTEGER " +
 533                             " DEFAULT 0");
 534
 535                     db .execSQL("ALTER TABLE " + ProviderTableMeta.DB_NAME +
 536                             " ADD COLUMN " + ProviderTableMeta.FILE_PUBLIC_LINK + " TEXT " +
 537                             " DEFAULT NULL");
 538
 539                     upgraded = true;
 540                     db.setTransactionSuccessful();
 541                 } finally {
 542                     db.endTransaction();
 543                 }
 544             }
 545             if (!upgraded)
 546                 Log_OC.i("SQL", "OUT of the ADD in onUpgrade; oldVersion == " + oldVersion + ", newVersion == " + newVersion);
 547         }
 548     }
 549
 550 }