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 as published by
   7  *   the Free Software Foundation, either version 2 of the License, or
   8  *   (at your option) any later version.
   9  *
  10  *   This program is distributed in the hope that it will be useful,
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *   GNU General Public License for more details.
  14  *
  15  *   You should have received a copy of the GNU General Public License
  16  *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17  *
  18  */
  19
  20 package com.owncloud.android.providers;
  21
  22 import java.util.HashMap;
  23
  24 import com.owncloud.android.db.ProviderMeta;
  25 import com.owncloud.android.db.ProviderMeta.ProviderTableMeta;
  26
  27
  28 import android.content.ContentProvider;
  29 import android.content.ContentUris;
  30 import android.content.ContentValues;
  31 import android.content.Context;
  32 import android.content.UriMatcher;
  33 import android.database.Cursor;
  34 import android.database.SQLException;
  35 import android.database.sqlite.SQLiteDatabase;
  36 import android.database.sqlite.SQLiteOpenHelper;
  37 import android.database.sqlite.SQLiteQueryBuilder;
  38 import android.net.Uri;
  39 import android.text.TextUtils;
  40 import android.util.Log;
  41
  42 /**
  43  * The ContentProvider for the ownCloud App.
  44  *
  45  * @author Bartek Przybylski
  46  *
  47  */
  48 public class FileContentProvider extends ContentProvider {
  49
  50     private DataBaseHelper mDbHelper;
  51
  52     private static HashMap<String, String> mProjectionMap;
  53     static {
  54         mProjectionMap = new HashMap<String, String>();
  55         mProjectionMap.put(ProviderTableMeta._ID, ProviderTableMeta._ID);
  56         mProjectionMap.put(ProviderTableMeta.FILE_PARENT,
  57                 ProviderTableMeta.FILE_PARENT);
  58         mProjectionMap.put(ProviderTableMeta.FILE_PATH,
  59                 ProviderTableMeta.FILE_PATH);
  60         mProjectionMap.put(ProviderTableMeta.FILE_NAME,
  61                 ProviderTableMeta.FILE_NAME);
  62         mProjectionMap.put(ProviderTableMeta.FILE_CREATION,
  63                 ProviderTableMeta.FILE_CREATION);
  64         mProjectionMap.put(ProviderTableMeta.FILE_MODIFIED,
  65                 ProviderTableMeta.FILE_MODIFIED);
  66         mProjectionMap.put(ProviderTableMeta.FILE_MODIFIED_AT_LAST_SYNC_FOR_DATA,
  67                 ProviderTableMeta.FILE_MODIFIED_AT_LAST_SYNC_FOR_DATA);
  68         mProjectionMap.put(ProviderTableMeta.FILE_CONTENT_LENGTH,
  69                 ProviderTableMeta.FILE_CONTENT_LENGTH);
  70         mProjectionMap.put(ProviderTableMeta.FILE_CONTENT_TYPE,
  71                 ProviderTableMeta.FILE_CONTENT_TYPE);
  72         mProjectionMap.put(ProviderTableMeta.FILE_STORAGE_PATH,
  73                 ProviderTableMeta.FILE_STORAGE_PATH);
  74         mProjectionMap.put(ProviderTableMeta.FILE_LAST_SYNC_DATE,
  75                 ProviderTableMeta.FILE_LAST_SYNC_DATE);
  76         mProjectionMap.put(ProviderTableMeta.FILE_LAST_SYNC_DATE_FOR_DATA,
  77                 ProviderTableMeta.FILE_LAST_SYNC_DATE_FOR_DATA);
  78         mProjectionMap.put(ProviderTableMeta.FILE_KEEP_IN_SYNC,
  79                 ProviderTableMeta.FILE_KEEP_IN_SYNC);
  80         mProjectionMap.put(ProviderTableMeta.FILE_ACCOUNT_OWNER,
  81                 ProviderTableMeta.FILE_ACCOUNT_OWNER);
  82     }
  83
  84     private static final int SINGLE_FILE = 1;
  85     private static final int DIRECTORY = 2;
  86     private static final int ROOT_DIRECTORY = 3;
  87     private static final UriMatcher mUriMatcher;
  88     static {
  89         mUriMatcher = new UriMatcher(UriMatcher.NO_MATCH);
  90         mUriMatcher.addURI(ProviderMeta.AUTHORITY_FILES, "/", ROOT_DIRECTORY);
  91         mUriMatcher.addURI(ProviderMeta.AUTHORITY_FILES, "file/", SINGLE_FILE);
  92         mUriMatcher.addURI(ProviderMeta.AUTHORITY_FILES, "file/#", SINGLE_FILE);
  93         mUriMatcher.addURI(ProviderMeta.AUTHORITY_FILES, "dir/#", DIRECTORY);
  94     }
  95
  96     @Override
  97     public int delete(Uri uri, String where, String[] whereArgs) {
  98         SQLiteDatabase db = mDbHelper.getWritableDatabase();
  99         int count = 0;
 100         switch (mUriMatcher.match(uri)) {
 101         case SINGLE_FILE:
 102             count = db.delete(ProviderTableMeta.DB_NAME,
 103                     ProviderTableMeta._ID
 104                             + "="
 105                             + uri.getPathSegments().get(1)
 106                             + (!TextUtils.isEmpty(where) ? " AND (" + where
 107                                     + ")" : ""), whereArgs);
 108             break;
 109         case ROOT_DIRECTORY:
 110             count = db.delete(ProviderTableMeta.DB_NAME, where, whereArgs);
 111             break;
 112         default:
 113             throw new IllegalArgumentException("Unknown uri: " + uri.toString());
 114         }
 115         getContext().getContentResolver().notifyChange(uri, null);
 116         return count;
 117     }
 118
 119     @Override
 120     public String getType(Uri uri) {
 121         switch (mUriMatcher.match(uri)) {
 122         case ROOT_DIRECTORY:
 123             return ProviderTableMeta.CONTENT_TYPE;
 124         case SINGLE_FILE:
 125             return ProviderTableMeta.CONTENT_TYPE_ITEM;
 126         default:
 127             throw new IllegalArgumentException("Unknown Uri id."
 128                     + uri.toString());
 129         }
 130     }
 131
 132     @Override
 133     public Uri insert(Uri uri, ContentValues values) {
 134         if (mUriMatcher.match(uri) != SINGLE_FILE &&
 135             mUriMatcher.match(uri) != ROOT_DIRECTORY) {
 136
 137             throw new IllegalArgumentException("Unknown uri id: " + uri);
 138         }
 139
 140         SQLiteDatabase db = mDbHelper.getWritableDatabase();
 141         long rowId = db.insert(ProviderTableMeta.DB_NAME, null, values);
 142         if (rowId > 0) {
 143             Uri insertedFileUri = ContentUris.withAppendedId(
 144                     ProviderTableMeta.CONTENT_URI_FILE, rowId);
 145             getContext().getContentResolver().notifyChange(insertedFileUri,
 146                     null);
 147             return insertedFileUri;
 148         }
 149         throw new SQLException("ERROR " + uri);
 150     }
 151
 152     @Override
 153     public boolean onCreate() {
 154         mDbHelper = new DataBaseHelper(getContext());
 155         return true;
 156     }
 157
 158     @Override
 159     public Cursor query(Uri uri, String[] projection, String selection,
 160             String[] selectionArgs, String sortOrder) {
 161         SQLiteQueryBuilder sqlQuery = new SQLiteQueryBuilder();
 162
 163         sqlQuery.setTables(ProviderTableMeta.DB_NAME);
 164         sqlQuery.setProjectionMap(mProjectionMap);
 165
 166         switch (mUriMatcher.match(uri)) {
 167         case ROOT_DIRECTORY:
 168             break;
 169         case DIRECTORY:
 170             sqlQuery.appendWhere(ProviderTableMeta.FILE_PARENT + "="
 171                     + uri.getPathSegments().get(1));
 172             break;
 173         case SINGLE_FILE:
 174             if (uri.getPathSegments().size() > 1) {
 175                 sqlQuery.appendWhere(ProviderTableMeta._ID + "="
 176                         + uri.getPathSegments().get(1));
 177             }
 178             break;
 179         default:
 180             throw new IllegalArgumentException("Unknown uri id: " + uri);
 181         }
 182
 183         String order;
 184         if (TextUtils.isEmpty(sortOrder)) {
 185             order = ProviderTableMeta.DEFAULT_SORT_ORDER;
 186         } else {
 187             order = sortOrder;
 188         }
 189
 190         SQLiteDatabase db = mDbHelper.getReadableDatabase();
 191         Cursor c = sqlQuery.query(db, projection, selection, selectionArgs,
 192                 null, null, order);
 193
 194         c.setNotificationUri(getContext().getContentResolver(), uri);
 195
 196         return c;
 197     }
 198
 199     @Override
 200     public int update(Uri uri, ContentValues values, String selection,
 201             String[] selectionArgs) {
 202         return mDbHelper.getWritableDatabase().update(
 203                 ProviderTableMeta.DB_NAME, values, selection, selectionArgs);
 204     }
 205
 206     class DataBaseHelper extends SQLiteOpenHelper {
 207
 208         public DataBaseHelper(Context context) {
 209             super(context, ProviderMeta.DB_NAME, null, ProviderMeta.DB_VERSION);
 210
 211         }
 212
 213         @Override
 214         public void onCreate(SQLiteDatabase db) {
 215             // files table
 216             Log.i("SQL", "Entering in onCreate");
 217             db.execSQL("CREATE TABLE " + ProviderTableMeta.DB_NAME + "("
 218                     + ProviderTableMeta._ID + " INTEGER PRIMARY KEY, "
 219                     + ProviderTableMeta.FILE_NAME + " TEXT, "
 220                     + ProviderTableMeta.FILE_PATH + " TEXT, "
 221                     + ProviderTableMeta.FILE_PARENT + " INTEGER, "
 222                     + ProviderTableMeta.FILE_CREATION + " INTEGER, "
 223                     + ProviderTableMeta.FILE_MODIFIED + " INTEGER, "
 224                     + ProviderTableMeta.FILE_CONTENT_TYPE + " TEXT, "
 225                     + ProviderTableMeta.FILE_CONTENT_LENGTH + " INTEGER, "
 226                     + ProviderTableMeta.FILE_STORAGE_PATH + " TEXT, "
 227                     + ProviderTableMeta.FILE_ACCOUNT_OWNER + " TEXT, "
 228                     + ProviderTableMeta.FILE_LAST_SYNC_DATE + " INTEGER, "
 229                     + ProviderTableMeta.FILE_KEEP_IN_SYNC + " INTEGER, "
 230                     + ProviderTableMeta.FILE_LAST_SYNC_DATE_FOR_DATA + " INTEGER, "
 231                     + ProviderTableMeta.FILE_MODIFIED_AT_LAST_SYNC_FOR_DATA + " INTEGER );"
 232                     );
 233         }
 234
 235         @Override
 236         public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
 237             Log.i("SQL", "Entering in onUpgrade");
 238             boolean upgraded = false;
 239             if (oldVersion == 1 && newVersion >= 2) {
 240                 Log.i("SQL", "Entering in the #1 ADD in onUpgrade");
 241                 db.execSQL("ALTER TABLE " + ProviderTableMeta.DB_NAME +
 242                            " ADD COLUMN " + ProviderTableMeta.FILE_KEEP_IN_SYNC  + " INTEGER " +
 243                            " DEFAULT 0");
 244                 upgraded = true;
 245             }
 246             if (oldVersion < 3 && newVersion >= 3) {
 247                 Log.i("SQL", "Entering in the #2 ADD in onUpgrade");
 248                 db.beginTransaction();
 249                 try {
 250                     db.execSQL("ALTER TABLE " + ProviderTableMeta.DB_NAME +
 251                                " ADD COLUMN " + ProviderTableMeta.FILE_LAST_SYNC_DATE_FOR_DATA  + " INTEGER " +
 252                                " DEFAULT 0");
 253
 254                     // assume there are not local changes pending to upload
 255                     db.execSQL("UPDATE " + ProviderTableMeta.DB_NAME +
 256                             " SET " + ProviderTableMeta.FILE_LAST_SYNC_DATE_FOR_DATA + " = " + System.currentTimeMillis() +
 257                             " WHERE " + ProviderTableMeta.FILE_STORAGE_PATH + " IS NOT NULL");
 258
 259                     upgraded = true;
 260                     db.setTransactionSuccessful();
 261                 } finally {
 262                     db.endTransaction();
 263                 }
 264             }
 265             if (oldVersion < 4 && newVersion >= 4) {
 266                 Log.i("SQL", "Entering in the #3 ADD in onUpgrade");
 267                 db.beginTransaction();
 268                 try {
 269                     db .execSQL("ALTER TABLE " + ProviderTableMeta.DB_NAME +
 270                            " ADD COLUMN " + ProviderTableMeta.FILE_MODIFIED_AT_LAST_SYNC_FOR_DATA  + " INTEGER " +
 271                            " DEFAULT 0");
 272
 273                     db.execSQL("UPDATE " + ProviderTableMeta.DB_NAME +
 274                            " SET " + ProviderTableMeta.FILE_MODIFIED_AT_LAST_SYNC_FOR_DATA + " = " + ProviderTableMeta.FILE_MODIFIED +
 275                            " WHERE " + ProviderTableMeta.FILE_STORAGE_PATH + " IS NOT NULL");
 276
 277                     upgraded = true;
 278                     db.setTransactionSuccessful();
 279                 } finally {
 280                     db.endTransaction();
 281                 }
 282             }
 283             if (!upgraded)
 284                 Log.i("SQL", "OUT of the ADD in onUpgrade; oldVersion == " + oldVersion + ", newVersion == " + newVersion);
 285         }
 286
 287     }
 288
 289 }