app/src/main/java/com/stoutner/privacybrowser/helpers/BookmarksDatabaseHelper.java

   1 /*
   2  * Copyright © 2016-2017 Soren Stoutner <soren@stoutner.com>.
   3  *
   4  * This file is part of Privacy Browser <https://www.stoutner.com/privacy-browser>.
   5  *
   6  * Privacy Browser is free software: you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation, either version 3 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * Privacy Browser is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with Privacy Browser.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 package com.stoutner.privacybrowser.helpers;
  21
  22 import android.content.ContentValues;
  23 import android.content.Context;
  24 import android.database.Cursor;
  25 import android.database.DatabaseUtils;
  26 import android.database.sqlite.SQLiteDatabase;
  27 import android.database.sqlite.SQLiteOpenHelper;
  28
  29 public class BookmarksDatabaseHelper extends SQLiteOpenHelper {
  30     private static final int SCHEMA_VERSION = 1;
  31     private static final String BOOKMARKS_DATABASE = "bookmarks.db";
  32     private static final String BOOKMARKS_TABLE = "bookmarks";
  33
  34     public static final String _ID = "_id";
  35     public static final String DISPLAY_ORDER = "displayorder";
  36     public static final String BOOKMARK_NAME = "bookmarkname";
  37     public static final String BOOKMARK_URL = "bookmarkurl";
  38     public static final String PARENT_FOLDER = "parentfolder";
  39     public static final String IS_FOLDER = "isfolder";
  40     public static final String FAVORITE_ICON = "favoriteicon";
  41
  42     // Initialize the database.  The lint warnings for the unused parameters are suppressed.
  43     public BookmarksDatabaseHelper(Context context, @SuppressWarnings("UnusedParameters") String name, SQLiteDatabase.CursorFactory cursorFactory, @SuppressWarnings("UnusedParameters") int version) {
  44         super(context, BOOKMARKS_DATABASE, cursorFactory, SCHEMA_VERSION);
  45     }
  46
  47     @Override
  48     public void onCreate(SQLiteDatabase bookmarksDatabase) {
  49         // Setup the SQL string to create the `bookmarks` table.
  50         final String CREATE_BOOKMARKS_TABLE = "CREATE TABLE " + BOOKMARKS_TABLE + " (" +
  51                 _ID + " integer primary key, " +
  52                 DISPLAY_ORDER + " integer, " +
  53                 BOOKMARK_NAME + " text, " +
  54                 BOOKMARK_URL + " text, " +
  55                 PARENT_FOLDER + " text, " +
  56                 IS_FOLDER + " boolean, " +
  57                 FAVORITE_ICON + " blob);";
  58
  59         // Create the `bookmarks` table if it doesn't exist.
  60         bookmarksDatabase.execSQL(CREATE_BOOKMARKS_TABLE);
  61     }
  62
  63     @Override
  64     public void onUpgrade(SQLiteDatabase bookmarksDatabase, int oldVersion, int newVersion) {
  65         // Code for upgrading the database will be added here when the schema version > 1.
  66     }
  67
  68     public void createBookmark(String bookmarkName, String bookmarkURL, int displayOrder, String parentFolder, byte[] favoriteIcon) {
  69         // We need to store the bookmark data in a `ContentValues`.
  70         ContentValues bookmarkContentValues = new ContentValues();
  71
  72         // ID is created automatically.
  73         bookmarkContentValues.put(DISPLAY_ORDER, displayOrder);
  74         bookmarkContentValues.put(BOOKMARK_NAME, bookmarkName);
  75         bookmarkContentValues.put(BOOKMARK_URL, bookmarkURL);
  76         bookmarkContentValues.put(PARENT_FOLDER, parentFolder);
  77         bookmarkContentValues.put(IS_FOLDER, false);
  78         bookmarkContentValues.put(FAVORITE_ICON, favoriteIcon);
  79
  80         // Get a writable database handle.
  81         SQLiteDatabase bookmarksDatabase = this.getWritableDatabase();
  82
  83         // Insert a new row.  The second argument is `null`, which makes it so that a completely null row cannot be created.
  84         bookmarksDatabase.insert(BOOKMARKS_TABLE, null, bookmarkContentValues);
  85
  86         // Close the database handle.
  87         bookmarksDatabase.close();
  88     }
  89
  90     public void createFolder(String folderName, int displayOrder, String parentFolder, byte[] favoriteIcon) {
  91         ContentValues bookmarkContentValues = new ContentValues();
  92
  93         // ID is created automatically.
  94         bookmarkContentValues.put(DISPLAY_ORDER, displayOrder);
  95         bookmarkContentValues.put(BOOKMARK_NAME, folderName);
  96         bookmarkContentValues.put(PARENT_FOLDER, parentFolder);
  97         bookmarkContentValues.put(IS_FOLDER, true);
  98         bookmarkContentValues.put(FAVORITE_ICON, favoriteIcon);
  99
 100         // Get a writable database handle.
 101         SQLiteDatabase bookmarksDatabase = this.getWritableDatabase();
 102
 103         // The second argument is `null`, which makes it so that completely null rows cannot be created.  Not a problem in our case.
 104         bookmarksDatabase.insert(BOOKMARKS_TABLE, null, bookmarkContentValues);
 105
 106         // Close the database handle.
 107         bookmarksDatabase.close();
 108     }
 109
 110     public Cursor getBookmarkCursor(int databaseId) {
 111         // Get a readable database handle.
 112         SQLiteDatabase bookmarksDatabase = this.getReadableDatabase();
 113
 114         // Prepare the SQL statement to get the `Cursor` for `databaseId`
 115         final String GET_ONE_BOOKMARK = "SELECT * FROM " + BOOKMARKS_TABLE +
 116                 " WHERE " + _ID + " = " + databaseId;
 117
 118         // Return the results as a `Cursor`.  The second argument is `null` because there are no `selectionArgs`.  We can't close the `Cursor` because we need to use it in the parent activity.
 119         return bookmarksDatabase.rawQuery(GET_ONE_BOOKMARK, null);
 120     }
 121
 122     public String getFolderName (int databaseId) {
 123         // Get a readable database handle.
 124         SQLiteDatabase bookmarksDatabase = this.getReadableDatabase();
 125
 126         // Prepare the SQL statement to get the `Cursor` for the folder.
 127         final String GET_FOLDER = "SELECT * FROM " + BOOKMARKS_TABLE +
 128                 " WHERE " + _ID + " = " + databaseId;
 129
 130         // Get `folderCursor`.  The second argument is `null` because there are no `selectionArgs`.
 131         Cursor folderCursor = bookmarksDatabase.rawQuery(GET_FOLDER, null);
 132
 133         // Get `folderName`.
 134         folderCursor.moveToFirst();
 135         String folderName = folderCursor.getString(folderCursor.getColumnIndex(BOOKMARK_NAME));
 136
 137         // Close the cursor and the database handle.
 138         folderCursor.close();
 139         bookmarksDatabase.close();
 140
 141         // Return the folder name.
 142         return folderName;
 143     }
 144
 145     public Cursor getFolderCursor(String folderName) {
 146         // Get a readable database handle.
 147         SQLiteDatabase bookmarksDatabase = this.getReadableDatabase();
 148
 149         // SQL escape `folderName`.
 150         folderName = DatabaseUtils.sqlEscapeString(folderName);
 151
 152         // Prepare the SQL statement to get the `Cursor` for the folder.
 153         final String GET_FOLDER = "SELECT * FROM " + BOOKMARKS_TABLE +
 154                 " WHERE " + BOOKMARK_NAME + " = " + folderName +
 155                 " AND " + IS_FOLDER + " = " + 1;
 156
 157         // Return the results as a `Cursor`.  The second argument is `null` because there are no `selectionArgs`.
 158         // We can't close the `Cursor` because we need to use it in the parent activity.
 159         return bookmarksDatabase.rawQuery(GET_FOLDER, null);
 160     }
 161
 162     public Cursor getFoldersCursorExcept(String exceptFolders) {
 163         // Get a readable database handle.
 164         SQLiteDatabase bookmarksDatabase = this.getReadableDatabase();
 165
 166         // Prepare the SQL statement to get the `Cursor` for the folders.
 167         final String GET_FOLDERS_EXCEPT = "SELECT * FROM " + BOOKMARKS_TABLE +
 168                 " WHERE " + IS_FOLDER + " = " + 1 +
 169                 " AND " + BOOKMARK_NAME + " NOT IN (" + exceptFolders +
 170                 ") ORDER BY " + BOOKMARK_NAME + " ASC";
 171
 172         // Return the results as a `Cursor`.  The second argument is `null` because there are no `selectionArgs`.
 173         // We can't close the `Cursor` because we need to use it in the parent activity.
 174         return bookmarksDatabase.rawQuery(GET_FOLDERS_EXCEPT, null);
 175     }
 176
 177     public Cursor getSubfoldersCursor(String currentFolder) {
 178         // Get a readable database handle.
 179         SQLiteDatabase bookmarksDatabase = this.getReadableDatabase();
 180
 181         // SQL escape `currentFolder.
 182         currentFolder = DatabaseUtils.sqlEscapeString(currentFolder);
 183
 184         // Prepare the SQL statement to get the `Cursor` for the subfolders.
 185         final String GET_SUBFOLDERS = "SELECT * FROM " + BOOKMARKS_TABLE +
 186                 " WHERE " + PARENT_FOLDER + " = " + currentFolder +
 187                 " AND " + IS_FOLDER + " = " + 1;
 188
 189         // Return the results as a `Cursor`.  The second argument is `null` because there are no `selectionArgs`.
 190         // We can't close the `Cursor` because we need to use it in the parent activity.
 191         return bookmarksDatabase.rawQuery(GET_SUBFOLDERS, null);
 192     }
 193
 194     public String getParentFolder(String currentFolder) {
 195         // Get a readable database handle.
 196         SQLiteDatabase bookmarksDatabase = this.getReadableDatabase();
 197
 198         // SQL escape `currentFolder`.
 199         currentFolder = DatabaseUtils.sqlEscapeString(currentFolder);
 200
 201         // Prepare the SQL statement to get the parent folder.
 202         final String GET_PARENT_FOLDER = "SELECT * FROM " + BOOKMARKS_TABLE +
 203                 " WHERE " + IS_FOLDER + " = " + 1 +
 204                 " AND " + BOOKMARK_NAME + " = " + currentFolder;
 205
 206         // The second argument is `null` because there are no `selectionArgs`.
 207         Cursor bookmarkCursor = bookmarksDatabase.rawQuery(GET_PARENT_FOLDER, null);
 208         bookmarkCursor.moveToFirst();
 209
 210         // Store the name of the parent folder.
 211         String parentFolder = bookmarkCursor.getString(bookmarkCursor.getColumnIndex(PARENT_FOLDER));
 212
 213         // Close the `Cursor`.
 214         bookmarkCursor.close();
 215
 216         return parentFolder;
 217     }
 218
 219     public Cursor getAllFoldersCursor() {
 220         // Get a readable database handle.
 221         SQLiteDatabase bookmarksDatabase = this.getReadableDatabase();
 222
 223         // Prepare the SQL statement to get the `Cursor` for all the folders.
 224         final String GET_ALL_FOLDERS = "SELECT * FROM " + BOOKMARKS_TABLE +
 225                 " WHERE " + IS_FOLDER + " = " + 1;
 226
 227         // Return the results as a `Cursor`.  The second argument is `null` because there are no `selectionArgs`.
 228         // We can't close the `Cursor` because we need to use it in the parent activity.
 229         return bookmarksDatabase.rawQuery(GET_ALL_FOLDERS, null);
 230     }
 231
 232     public Cursor getAllBookmarksCursor() {
 233         // Get a readable database handle.
 234         SQLiteDatabase bookmarksDatabase = this.getReadableDatabase();
 235
 236         // Get everything in `BOOKMARKS_TABLE`.
 237         final String GET_ALL_BOOKMARKS = "SELECT * FROM " + BOOKMARKS_TABLE;
 238
 239         // Return the results as a Cursor.  The second argument is `null` because there are no selectionArgs.
 240         // We can't close the Cursor because we need to use it in the parent activity.
 241         return bookmarksDatabase.rawQuery(GET_ALL_BOOKMARKS, null);
 242     }
 243
 244     public Cursor getAllBookmarksCursorByDisplayOrder(String folderName) {
 245         // Get a readable database handle.
 246         SQLiteDatabase bookmarksDatabase = this.getReadableDatabase();
 247
 248         // SQL escape `folderName`.
 249         folderName = DatabaseUtils.sqlEscapeString(folderName);
 250
 251         // Get everything in the `BOOKMARKS_TABLE` with `folderName` as the `PARENT_FOLDER`.
 252         final String GET_ALL_BOOKMARKS = "SELECT * FROM " + BOOKMARKS_TABLE +
 253                 " WHERE " + PARENT_FOLDER + " = " + folderName +
 254                 " ORDER BY " + DISPLAY_ORDER + " ASC";
 255
 256         // Return the results as a `Cursor`.  The second argument is `null` because there are no `selectionArgs`.  We can't close the `Cursor` because we need to use it in the parent activity.
 257         return bookmarksDatabase.rawQuery(GET_ALL_BOOKMARKS, null);
 258     }
 259
 260     public Cursor getBookmarksCursorExcept(long[] exceptIdLongArray, String folderName) {
 261         // Get a readable database handle.
 262         SQLiteDatabase bookmarksDatabase = this.getReadableDatabase();
 263
 264         // Prepare a string that contains the comma-separated list of IDs not to get.
 265         String doNotGetIdsString = "";
 266         // Extract the array to `doNotGetIdsString`.
 267         for (long databaseIdLong : exceptIdLongArray) {
 268             // If this is the first number, only add the number.
 269             if (doNotGetIdsString.isEmpty()) {
 270                 doNotGetIdsString = String.valueOf(databaseIdLong);
 271             } else {  // If there already is a number in the string, place a `,` before the number.
 272                 doNotGetIdsString = doNotGetIdsString + "," + databaseIdLong;
 273             }
 274         }
 275
 276         // SQL escape `folderName`.
 277         folderName = DatabaseUtils.sqlEscapeString(folderName);
 278
 279         // Prepare the SQL statement to select all items except those with the specified IDs.
 280         final String GET_All_BOOKMARKS_EXCEPT_SPECIFIED = "SELECT * FROM " + BOOKMARKS_TABLE +
 281                 " WHERE " + PARENT_FOLDER + " = " + folderName +
 282                 " AND " + _ID + " NOT IN (" + doNotGetIdsString +
 283                 ") ORDER BY " + DISPLAY_ORDER + " ASC";
 284
 285         // Return the results as a `Cursor`.  The second argument is `null` because there are no `selectionArgs`.
 286         // We can't close the `Cursor` because we need to use it in the parent activity.
 287         return bookmarksDatabase.rawQuery(GET_All_BOOKMARKS_EXCEPT_SPECIFIED, null);
 288     }
 289
 290     public boolean isFolder(int databaseId) {
 291         // Get a readable database handle.
 292         SQLiteDatabase bookmarksDatabase = this.getReadableDatabase();
 293
 294         // Prepare the SQL statement to determine if `databaseId` is a folder.
 295         final String CHECK_IF_FOLDER = "SELECT * FROM " + BOOKMARKS_TABLE +
 296                 " WHERE " + _ID + " = " + databaseId;
 297
 298         // Populate folderCursor.  The second argument is `null` because there are no `selectionArgs`.
 299         Cursor folderCursor = bookmarksDatabase.rawQuery(CHECK_IF_FOLDER, null);
 300
 301         // Ascertain if this database ID is a folder.
 302         folderCursor.moveToFirst();
 303         boolean isFolder = (folderCursor.getInt(folderCursor.getColumnIndex(IS_FOLDER)) == 1);
 304
 305         // Close the `Cursor` and the database handle.
 306         folderCursor.close();
 307         bookmarksDatabase.close();
 308
 309         return isFolder;
 310     }
 311
 312     public void updateBookmark(int databaseId, String bookmarkName, String bookmarkUrl) {
 313         // Store the updated values in `bookmarkContentValues`.
 314         ContentValues bookmarkContentValues = new ContentValues();
 315
 316         bookmarkContentValues.put(BOOKMARK_NAME, bookmarkName);
 317         bookmarkContentValues.put(BOOKMARK_URL, bookmarkUrl);
 318
 319         // Get a writable database handle.
 320         SQLiteDatabase bookmarksDatabase = this.getWritableDatabase();
 321
 322         // Update the bookmark.  The last argument is `null` because there are no `whereArgs`.
 323         bookmarksDatabase.update(BOOKMARKS_TABLE, bookmarkContentValues, _ID + " = " + databaseId, null);
 324
 325         // Close the database handle.
 326         bookmarksDatabase.close();
 327     }
 328
 329     public void updateBookmark(int databaseId, String bookmarkName, String bookmarkUrl, byte[] favoriteIcon) {
 330         // Store the updated values in `bookmarkContentValues`.
 331         ContentValues bookmarkContentValues = new ContentValues();
 332
 333         bookmarkContentValues.put(BOOKMARK_NAME, bookmarkName);
 334         bookmarkContentValues.put(BOOKMARK_URL, bookmarkUrl);
 335         bookmarkContentValues.put(FAVORITE_ICON, favoriteIcon);
 336
 337         // Get a writable database handle.
 338         SQLiteDatabase bookmarksDatabase = this.getWritableDatabase();
 339
 340         // Update the bookmark.  The last argument is `null` because there are no `whereArgs`.
 341         bookmarksDatabase.update(BOOKMARKS_TABLE, bookmarkContentValues, _ID + " = " + databaseId, null);
 342
 343         // Close the database handle.
 344         bookmarksDatabase.close();
 345     }
 346
 347     public void updateFolder(int databaseId, String oldFolderName, String newFolderName) {
 348         // Get a writable database handle.
 349         SQLiteDatabase bookmarksDatabase = this.getWritableDatabase();
 350
 351         // Update the folder first.  Store the updated values in `folderContentValues`.
 352         ContentValues folderContentValues = new ContentValues();
 353
 354         folderContentValues.put(BOOKMARK_NAME, newFolderName);
 355
 356         // Run the update on the folder.  The last argument is `null` because there are no `whereArgs`.
 357         bookmarksDatabase.update(BOOKMARKS_TABLE, folderContentValues, _ID + " = " + databaseId, null);
 358
 359
 360         // Update the bookmarks inside the folder with the new parent folder name.
 361         ContentValues bookmarkContentValues = new ContentValues();
 362
 363         bookmarkContentValues.put(PARENT_FOLDER, newFolderName);
 364
 365         // SQL escape `oldFolderName`.
 366         oldFolderName = DatabaseUtils.sqlEscapeString(oldFolderName);
 367
 368         // Run the update on the bookmarks.  The last argument is `null` because there are no `whereArgs`.
 369         bookmarksDatabase.update(BOOKMARKS_TABLE, bookmarkContentValues, PARENT_FOLDER + " = " + oldFolderName, null);
 370
 371         // Close the database handle.
 372         bookmarksDatabase.close();
 373     }
 374
 375     public void updateFolder(int databaseId, String oldFolderName, String newFolderName, byte[] folderIcon) {
 376         // Get a writable database handle.
 377         SQLiteDatabase bookmarksDatabase = this.getWritableDatabase();
 378
 379         // Update the folder first.  Store the updated values in `folderContentValues`.
 380         ContentValues folderContentValues = new ContentValues();
 381
 382         folderContentValues.put(BOOKMARK_NAME, newFolderName);
 383         folderContentValues.put(FAVORITE_ICON, folderIcon);
 384
 385         // Run the update on the folder.  The last argument is `null` because there are no `whereArgs`.
 386         bookmarksDatabase.update(BOOKMARKS_TABLE, folderContentValues, _ID + " = " + databaseId, null);
 387
 388
 389         // Update the bookmarks inside the folder with the new parent folder name.
 390         ContentValues bookmarkContentValues = new ContentValues();
 391
 392         bookmarkContentValues.put(PARENT_FOLDER, newFolderName);
 393
 394         // SQL escape `oldFolderName`.
 395         oldFolderName = DatabaseUtils.sqlEscapeString(oldFolderName);
 396
 397         // Run the update on the bookmarks.  The last argument is `null` because there are no `whereArgs`.
 398         bookmarksDatabase.update(BOOKMARKS_TABLE, bookmarkContentValues, PARENT_FOLDER + " = " + oldFolderName, null);
 399
 400         // Close the database handle.
 401         bookmarksDatabase.close();
 402     }
 403
 404     public void updateBookmarkDisplayOrder(int databaseId, int displayOrder) {
 405         // Get a writable database handle.
 406         SQLiteDatabase bookmarksDatabase = this.getWritableDatabase();
 407
 408         // Store the new display order in `bookmarkContentValues`.
 409         ContentValues bookmarkContentValues = new ContentValues();
 410         bookmarkContentValues.put(DISPLAY_ORDER, displayOrder);
 411
 412         // Update the database.  The last argument is `null` because there are no `whereArgs`.
 413         bookmarksDatabase.update(BOOKMARKS_TABLE, bookmarkContentValues, _ID + " = " + databaseId, null);
 414
 415         // Close the database handle.
 416         bookmarksDatabase.close();
 417     }
 418
 419     public void moveToFolder(int databaseId, String newFolder) {
 420         // Get a writable database handle.
 421         SQLiteDatabase bookmarksDatabase = this.getWritableDatabase();
 422
 423         // Get the highest `DISPLAY_ORDER` in the new folder
 424         String newFolderSqlEscaped = DatabaseUtils.sqlEscapeString(newFolder);
 425         final String NEW_FOLDER = "SELECT * FROM " + BOOKMARKS_TABLE +
 426                 " WHERE " + PARENT_FOLDER + " = " + newFolderSqlEscaped +
 427                 " ORDER BY " + DISPLAY_ORDER + " ASC";
 428         // The second argument is `null` because there are no `selectionArgs`.
 429         Cursor newFolderCursor = bookmarksDatabase.rawQuery(NEW_FOLDER, null);
 430         int displayOrder;
 431         if (newFolderCursor.getCount() > 0) {
 432             newFolderCursor.moveToLast();
 433             displayOrder = newFolderCursor.getInt(newFolderCursor.getColumnIndex(DISPLAY_ORDER)) + 1;
 434         } else {
 435             displayOrder = 0;
 436         }
 437         newFolderCursor.close();
 438
 439         // Store the new values in `bookmarkContentValues`.
 440         ContentValues bookmarkContentValues = new ContentValues();
 441         bookmarkContentValues.put(DISPLAY_ORDER, displayOrder);
 442         bookmarkContentValues.put(PARENT_FOLDER, newFolder);
 443
 444         // Update the database.  The last argument is `null` because there are no `whereArgs`.
 445         bookmarksDatabase.update(BOOKMARKS_TABLE, bookmarkContentValues, _ID + " = " + databaseId, null);
 446
 447         // Close the database handle.
 448         bookmarksDatabase.close();
 449     }
 450
 451     public void deleteBookmark(int databaseId) {
 452         // Get a writable database handle.
 453         SQLiteDatabase bookmarksDatabase = this.getWritableDatabase();
 454
 455         // Deletes the row with the given `databaseId`.  The last argument is `null` because we don't need additional parameters.
 456         bookmarksDatabase.delete(BOOKMARKS_TABLE, _ID + " = " + databaseId, null);
 457
 458         // Close the database handle.
 459         bookmarksDatabase.close();
 460     }
 461 }