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