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

   1 /*
   2  * Copyright © 2016-2019 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     static final String BOOKMARKS_DATABASE = "bookmarks.db";
  32     static final String BOOKMARKS_TABLE = "bookmarks";
  33
  34     public static final String _ID = "_id";
  35     public static final String BOOKMARK_NAME = "bookmarkname";
  36     public static final String BOOKMARK_URL = "bookmarkurl";
  37     public static final String PARENT_FOLDER = "parentfolder";
  38     public static final String DISPLAY_ORDER = "displayorder";
  39     public static final String IS_FOLDER = "isfolder";
  40     public static final String FAVORITE_ICON = "favoriteicon";
  41
  42     static final String CREATE_BOOKMARKS_TABLE = "CREATE TABLE " + BOOKMARKS_TABLE + " (" +
  43             _ID + " INTEGER PRIMARY KEY, " +
  44             BOOKMARK_NAME + " TEXT, " +
  45             BOOKMARK_URL + " TEXT, " +
  46             PARENT_FOLDER + " TEXT, " +
  47             DISPLAY_ORDER + " INTEGER, " +
  48             IS_FOLDER + " BOOLEAN, " +
  49             FAVORITE_ICON + " BLOB)";
  50
  51     // Initialize the database.  The lint warnings for the unused parameters are suppressed.
  52     public BookmarksDatabaseHelper(Context context, @SuppressWarnings("UnusedParameters") String name, SQLiteDatabase.CursorFactory cursorFactory, @SuppressWarnings("UnusedParameters") int version) {
  53         super(context, BOOKMARKS_DATABASE, cursorFactory, SCHEMA_VERSION);
  54     }
  55
  56     @Override
  57     public void onCreate(SQLiteDatabase bookmarksDatabase) {
  58         // Create the bookmarks table.
  59         bookmarksDatabase.execSQL(CREATE_BOOKMARKS_TABLE);
  60     }
  61
  62     @Override
  63     public void onUpgrade(SQLiteDatabase bookmarksDatabase, int oldVersion, int newVersion) {
  64         // Code for upgrading the database will be added here when the schema version > 1.
  65     }
  66
  67     // Create a bookmark.
  68     public void createBookmark(String bookmarkName, String bookmarkURL, String parentFolder, int displayOrder, byte[] favoriteIcon) {
  69         // Store the bookmark data in a `ContentValues`.
  70         ContentValues bookmarkContentValues = new ContentValues();
  71
  72         // ID is created automatically.
  73         bookmarkContentValues.put(BOOKMARK_NAME, bookmarkName);
  74         bookmarkContentValues.put(BOOKMARK_URL, bookmarkURL);
  75         bookmarkContentValues.put(PARENT_FOLDER, parentFolder);
  76         bookmarkContentValues.put(DISPLAY_ORDER, displayOrder);
  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     // Create a bookmark from content values.
  91     void createBookmark(ContentValues contentValues) {
  92         // Get a writable database.
  93         SQLiteDatabase bookmarksDatabase = this.getWritableDatabase();
  94
  95         // Insert a new row.  The second argument is `null`, which makes it so that a completely null row cannot be created.
  96         bookmarksDatabase.insert(BOOKMARKS_TABLE, null, contentValues);
  97
  98         // Close the database handle.
  99         bookmarksDatabase.close();
 100     }
 101
 102     // Create a folder.
 103     public void createFolder(String folderName, String parentFolder, byte[] favoriteIcon) {
 104         ContentValues bookmarkContentValues = new ContentValues();
 105
 106         // ID is created automatically.  Folders are always created at the top of the list.
 107         bookmarkContentValues.put(BOOKMARK_NAME, folderName);
 108         bookmarkContentValues.put(PARENT_FOLDER, parentFolder);
 109         bookmarkContentValues.put(DISPLAY_ORDER, 0);
 110         bookmarkContentValues.put(IS_FOLDER, true);
 111         bookmarkContentValues.put(FAVORITE_ICON, favoriteIcon);
 112
 113         // Get a writable database handle.
 114         SQLiteDatabase bookmarksDatabase = this.getWritableDatabase();
 115
 116         // The second argument is `null`, which makes it so that completely null rows cannot be created.  Not a problem in our case.
 117         bookmarksDatabase.insert(BOOKMARKS_TABLE, null, bookmarkContentValues);
 118
 119         // Close the database handle.
 120         bookmarksDatabase.close();
 121     }
 122
 123     // Get a `Cursor` for the bookmark with the specified database ID.
 124     public Cursor getBookmark(int databaseId) {
 125         // Get a readable database handle.
 126         SQLiteDatabase bookmarksDatabase = this.getReadableDatabase();
 127
 128         // Prepare the SQL statement to get the cursor for the database ID.
 129         String GET_ONE_BOOKMARK = "SELECT * FROM " + BOOKMARKS_TABLE +
 130                 " WHERE " + _ID + " = " + databaseId;
 131
 132         // 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.
 133         return bookmarksDatabase.rawQuery(GET_ONE_BOOKMARK, null);
 134     }
 135
 136     // Get the folder name for the specified database ID.
 137     public String getFolderName (int databaseId) {
 138         // Get a readable database handle.
 139         SQLiteDatabase bookmarksDatabase = this.getReadableDatabase();
 140
 141         // Prepare the SQL statement to get the cursor for the folder.
 142         String GET_FOLDER = "SELECT * FROM " + BOOKMARKS_TABLE +
 143                 " WHERE " + _ID + " = " + databaseId;
 144
 145         // Get a folder cursor.
 146         Cursor folderCursor = bookmarksDatabase.rawQuery(GET_FOLDER, null);
 147
 148         // Get the folder name.
 149         folderCursor.moveToFirst();
 150         String folderName = folderCursor.getString(folderCursor.getColumnIndex(BOOKMARK_NAME));
 151
 152         // Close the cursor and the database handle.
 153         folderCursor.close();
 154         bookmarksDatabase.close();
 155
 156         // Return the folder name.
 157         return folderName;
 158     }
 159
 160     // Get the database ID for the specified folder name.
 161     public int getFolderDatabaseId (String folderName) {
 162         // Get a readable database handle.
 163         SQLiteDatabase bookmarksDatabase = this.getReadableDatabase();
 164
 165         // SQL escape `folderName`.
 166         folderName = DatabaseUtils.sqlEscapeString(folderName);
 167
 168         // Prepare the SQL statement to get the `Cursor` for the folder.
 169         String GET_FOLDER = "SELECT * FROM " + BOOKMARKS_TABLE +
 170                 " WHERE " + BOOKMARK_NAME + " = " + folderName +
 171                 " AND " + IS_FOLDER + " = " + 1;
 172
 173         // Get `folderCursor`.  The second argument is `null` because there are no `selectionArgs`.
 174         Cursor folderCursor = bookmarksDatabase.rawQuery(GET_FOLDER, null);
 175
 176         // Get the database ID.
 177         folderCursor.moveToFirst();
 178         int databaseId = folderCursor.getInt(folderCursor.getColumnIndex(_ID));
 179
 180         // Close the cursor and the database handle.
 181         folderCursor.close();
 182         bookmarksDatabase.close();
 183
 184         // Return the database ID.
 185         return databaseId;
 186     }
 187
 188     // Get a cursor for the specified folder name.
 189     public Cursor getFolder(String folderName) {
 190         // Get a readable database handle.
 191         SQLiteDatabase bookmarksDatabase = this.getReadableDatabase();
 192
 193         // SQL escape `folderName`.
 194         folderName = DatabaseUtils.sqlEscapeString(folderName);
 195
 196         // Prepare the SQL statement to get the `Cursor` for the folder.
 197         String GET_FOLDER = "SELECT * FROM " + BOOKMARKS_TABLE +
 198                 " WHERE " + BOOKMARK_NAME + " = " + folderName +
 199                 " AND " + IS_FOLDER + " = " + 1;
 200
 201         // Return the results as a `Cursor`.  The second argument is `null` because there are no `selectionArgs`.
 202         // We can't close the `Cursor` because we need to use it in the parent activity.
 203         return bookmarksDatabase.rawQuery(GET_FOLDER, null);
 204     }
 205
 206     // Get a cursor of all the folders except those specified.
 207     public Cursor getFoldersExcept(String exceptFolders) {
 208         // Get a readable database handle.
 209         SQLiteDatabase bookmarksDatabase = this.getReadableDatabase();
 210
 211         // Prepare the SQL statement to get the `Cursor` for the folders.
 212         String GET_FOLDERS_EXCEPT = "SELECT * FROM " + BOOKMARKS_TABLE +
 213                 " WHERE " + IS_FOLDER + " = " + 1 +
 214                 " AND " + BOOKMARK_NAME + " NOT IN (" + exceptFolders +
 215                 ") ORDER BY " + BOOKMARK_NAME + " ASC";
 216
 217         // Return the results as a `Cursor`.  The second argument is `null` because there are no `selectionArgs`.
 218         // We can't close the `Cursor` because we need to use it in the parent activity.
 219         return bookmarksDatabase.rawQuery(GET_FOLDERS_EXCEPT, null);
 220     }
 221
 222     // Get a cursor with all the subfolders of the specified folder.
 223     public Cursor getSubfolders(String currentFolder) {
 224         // Get a readable database handle.
 225         SQLiteDatabase bookmarksDatabase = this.getReadableDatabase();
 226
 227         // SQL escape `currentFolder.
 228         currentFolder = DatabaseUtils.sqlEscapeString(currentFolder);
 229
 230         // Prepare the SQL statement to get the `Cursor` for the subfolders.
 231         String GET_SUBFOLDERS = "SELECT * FROM " + BOOKMARKS_TABLE +
 232                 " WHERE " + PARENT_FOLDER + " = " + currentFolder +
 233                 " AND " + IS_FOLDER + " = " + 1;
 234
 235         // Return the results as a `Cursor`.  The second argument is `null` because there are no `selectionArgs`.
 236         // We can't close the `Cursor` because we need to use it in the parent activity.
 237         return bookmarksDatabase.rawQuery(GET_SUBFOLDERS, null);
 238     }
 239
 240     // Get the name of the parent folder.
 241     public String getParentFolderName(String currentFolder) {
 242         // Get a readable database handle.
 243         SQLiteDatabase bookmarksDatabase = this.getReadableDatabase();
 244
 245         // SQL escape `currentFolder`.
 246         currentFolder = DatabaseUtils.sqlEscapeString(currentFolder);
 247
 248         // Prepare the SQL statement to get the current folder.
 249         String GET_CURRENT_FOLDER = "SELECT * FROM " + BOOKMARKS_TABLE +
 250                 " WHERE " + IS_FOLDER + " = " + 1 +
 251                 " AND " + BOOKMARK_NAME + " = " + currentFolder;
 252
 253         // Get the bookmark cursor and move to the first entry.
 254         Cursor bookmarkCursor = bookmarksDatabase.rawQuery(GET_CURRENT_FOLDER, null);
 255         bookmarkCursor.moveToFirst();
 256
 257         // Store the name of the parent folder.
 258         String parentFolder = bookmarkCursor.getString(bookmarkCursor.getColumnIndex(PARENT_FOLDER));
 259
 260         // Close the cursor.
 261         bookmarkCursor.close();
 262
 263         return parentFolder;
 264     }
 265
 266     // Get the name of the parent folder.
 267     public String getParentFolderName(int databaseId) {
 268         // Get a readable database handle.
 269         SQLiteDatabase bookmarksDatabase = this.getReadableDatabase();
 270
 271         // Prepare the SQL statement to get the current bookmark.
 272         String GET_BOOKMARK = "SELECT * FROM " + BOOKMARKS_TABLE +
 273                 " WHERE " + _ID + " = " + databaseId;
 274
 275         // Get the bookmark cursor and move to the first entry.
 276         Cursor bookmarkCursor = bookmarksDatabase.rawQuery(GET_BOOKMARK, null);
 277         bookmarkCursor.moveToFirst();
 278
 279         // Store the name of the parent folder.
 280         String parentFolder = bookmarkCursor.getString(bookmarkCursor.getColumnIndex(PARENT_FOLDER));
 281
 282         // Close the cursor.
 283         bookmarkCursor.close();
 284
 285         return parentFolder;
 286     }
 287
 288     // Get a cursor of all the folders.
 289     public Cursor getAllFolders() {
 290         // Get a readable database handle.
 291         SQLiteDatabase bookmarksDatabase = this.getReadableDatabase();
 292
 293         // Prepare the SQL statement to get the `Cursor` for all the folders.
 294         String GET_ALL_FOLDERS = "SELECT * FROM " + BOOKMARKS_TABLE +
 295                 " WHERE " + IS_FOLDER + " = " + 1 +
 296                 " ORDER BY " + BOOKMARK_NAME + " ASC";
 297
 298         // Return the results as a `Cursor`.  The second argument is `null` because there are no `selectionArgs`.
 299         // We can't close the `Cursor` because we need to use it in the parent activity.
 300         return bookmarksDatabase.rawQuery(GET_ALL_FOLDERS, null);
 301     }
 302
 303     // Get a cursor for all bookmarks and folders.
 304     public Cursor getAllBookmarks() {
 305         // Get a readable database handle.
 306         SQLiteDatabase bookmarksDatabase = this.getReadableDatabase();
 307
 308         // Get everything in the bookmarks table.
 309         String GET_ALL_BOOKMARKS = "SELECT * FROM " + BOOKMARKS_TABLE;
 310
 311         // Return the result as a Cursor.  The Cursor cannot be closed because it is used in the parent activity.
 312         return bookmarksDatabase.rawQuery(GET_ALL_BOOKMARKS, null);
 313     }
 314
 315     // Get a cursor for all bookmarks and folders ordered by display order.
 316     public Cursor getAllBookmarksByDisplayOrder() {
 317         // Get a readable database handle.
 318         SQLiteDatabase bookmarksDatabase = this.getReadableDatabase();
 319
 320         // Get everything in the bookmarks table ordered by display order.
 321         String GET_ALL_BOOKMARKS = "SELECT * FROM " + BOOKMARKS_TABLE +
 322                 " ORDER BY " + DISPLAY_ORDER + " ASC";
 323
 324         // Return the result as a cursor.  The cursor cannot be closed because it is used in the parent activity.
 325         return bookmarksDatabase.rawQuery(GET_ALL_BOOKMARKS, null);
 326     }
 327
 328     // Get a cursor for all bookmarks and folders except those with the specified IDs.
 329     public Cursor getAllBookmarksExcept(long[] exceptIdLongArray) {
 330         // Get a readable database handle.
 331         SQLiteDatabase bookmarksDatabase = this.getReadableDatabase();
 332
 333         // Prepare a string builder to contain the comma-separated list of IDs not to get.
 334         StringBuilder idsNotToGetStringBuilder = new StringBuilder();
 335
 336         // Extract the array of IDs not to get to the string builder.
 337         for (long databaseIdLong : exceptIdLongArray) {
 338             if (idsNotToGetStringBuilder.length() == 0) {  // This is the first number, so only add the number.
 339                 idsNotToGetStringBuilder.append(databaseIdLong);
 340             } else {  // This is not the first number, so place a `,` before the new number.
 341                 idsNotToGetStringBuilder.append(",");
 342                 idsNotToGetStringBuilder.append(databaseIdLong);
 343             }
 344         }
 345
 346         // Prepare the SQL statement to select all items except those with the specified IDs.
 347         String GET_ALL_BOOKMARKS_EXCEPT_SPECIFIED = "SELECT * FROM " + BOOKMARKS_TABLE +
 348                 " WHERE " + _ID + " NOT IN (" + idsNotToGetStringBuilder.toString() + ")";
 349
 350         // Return the results as a cursor.  The cursor cannot be closed because it will be used in the parent activity.
 351         return bookmarksDatabase.rawQuery(GET_ALL_BOOKMARKS_EXCEPT_SPECIFIED, null);
 352     }
 353
 354     // Get a cursor for all bookmarks and folders by display order except for a specific of IDs.
 355     public Cursor getAllBookmarksByDisplayOrderExcept(long[] exceptIdLongArray) {
 356         // Get a readable database handle.
 357         SQLiteDatabase bookmarksDatabase = this.getReadableDatabase();
 358
 359         // Prepare a string builder to contain the comma-separated list of IDs not to get.
 360         StringBuilder idsNotToGetStringBuilder = new StringBuilder();
 361
 362         // Extract the array of IDs not to get to the string builder.
 363         for (long databaseIdLong : exceptIdLongArray) {
 364             if (idsNotToGetStringBuilder.length() == 0) {  // This is the first number, so only add the number.
 365                 idsNotToGetStringBuilder.append(databaseIdLong);
 366             } else {  // This is not the first number, so place a `,` before the new number.
 367                 idsNotToGetStringBuilder.append(",");
 368                 idsNotToGetStringBuilder.append(databaseIdLong);
 369             }
 370         }
 371
 372         // Prepare the SQL statement to select all items except those with the specified IDs.
 373         String GET_ALL_BOOKMARKS_EXCEPT_SPECIFIED = "SELECT * FROM " + BOOKMARKS_TABLE +
 374                 " WHERE " + _ID + " NOT IN (" + idsNotToGetStringBuilder.toString() +
 375                 ") ORDER BY " + DISPLAY_ORDER + " ASC";
 376
 377         // Return the results as a cursor.  The cursor cannot be closed because it will be used in the parent activity.
 378         return bookmarksDatabase.rawQuery(GET_ALL_BOOKMARKS_EXCEPT_SPECIFIED, null);
 379     }
 380
 381     // Get a cursor for bookmarks and folders in the specified folder.
 382     public Cursor getBookmarks(String folderName) {
 383         // Get a readable database handle.
 384         SQLiteDatabase bookmarksDatabase = this.getReadableDatabase();
 385
 386         // SQL escape the folder name.
 387         folderName = DatabaseUtils.sqlEscapeString(folderName);
 388
 389         // Get everything in the bookmarks table with `folderName` as the `PARENT_FOLDER`.
 390         String GET_BOOKMARKS = "SELECT * FROM " + BOOKMARKS_TABLE +
 391                 " WHERE " + PARENT_FOLDER + " = " + folderName;
 392
 393         // Return the result as a cursor.  The cursor cannot be closed because it is used in the parent activity.
 394         return bookmarksDatabase.rawQuery(GET_BOOKMARKS, null);
 395     }
 396
 397     // Get a cursor for bookmarks and folders in the specified folder ordered by display order.
 398     public Cursor getBookmarksByDisplayOrder(String folderName) {
 399         // Get a readable database handle.
 400         SQLiteDatabase bookmarksDatabase = this.getReadableDatabase();
 401
 402         // SQL escape `folderName`.
 403         folderName = DatabaseUtils.sqlEscapeString(folderName);
 404
 405         // Get everything in the bookmarks table with `folderName` as the `PARENT_FOLDER`.
 406         String GET_BOOKMARKS = "SELECT * FROM " + BOOKMARKS_TABLE +
 407                 " WHERE " + PARENT_FOLDER + " = " + folderName +
 408                 " ORDER BY " + DISPLAY_ORDER + " ASC";
 409
 410         // Return the result as a cursor.  The cursor cannot be closed because it is used in the parent activity.
 411         return bookmarksDatabase.rawQuery(GET_BOOKMARKS, null);
 412     }
 413
 414     // Get a cursor for bookmarks and folders in the specified folder except for ta specific list of IDs.
 415     public Cursor getBookmarksExcept(long[] exceptIdLongArray, String folderName) {
 416         // Get a readable database handle.
 417         SQLiteDatabase bookmarksDatabase = this.getReadableDatabase();
 418
 419         // Prepare a string builder to contain the comma-separated list of IDs not to get.
 420         StringBuilder idsNotToGetStringBuilder = new StringBuilder();
 421
 422         // Extract the array of IDs not to get to the string builder.
 423         for (long databaseIdLong : exceptIdLongArray) {
 424             if (idsNotToGetStringBuilder.length() == 0) {  // This is the first number, so only add the number.
 425                 idsNotToGetStringBuilder.append(databaseIdLong);
 426             } else {  // This is not the first number, so place a `,` before the new number.
 427                 idsNotToGetStringBuilder.append(",");
 428                 idsNotToGetStringBuilder.append(databaseIdLong);
 429             }
 430         }
 431
 432         // SQL escape the folder name.
 433         folderName = DatabaseUtils.sqlEscapeString(folderName);
 434
 435         // Get everything in the bookmarks table with `folderName` as the `PARENT_FOLDER` except those with the specified IDs.
 436         String GET_BOOKMARKS_EXCEPT_SPECIFIED = "SELECT * FROM " + BOOKMARKS_TABLE +
 437                 " WHERE " + PARENT_FOLDER + " = " + folderName +
 438                 " AND " + _ID + " NOT IN (" + idsNotToGetStringBuilder.toString() + ")";
 439
 440         // Return the result as a cursor.  The cursor cannot be closed because it is used in the parent activity.
 441         return bookmarksDatabase.rawQuery(GET_BOOKMARKS_EXCEPT_SPECIFIED, null);
 442     }
 443
 444     // Get a cursor for bookmarks and folders in the specified folder by display order except for a specific list of IDs.
 445     public Cursor getBookmarksByDisplayOrderExcept(long[] exceptIdLongArray, String folderName) {
 446         // Get a readable database handle.
 447         SQLiteDatabase bookmarksDatabase = this.getReadableDatabase();
 448
 449         // Prepare a string builder to contain the comma-separated list of IDs not to get.
 450         StringBuilder idsNotToGetStringBuilder = new StringBuilder();
 451
 452         // Extract the array of IDs not to get to the string builder.
 453         for (long databaseIdLong : exceptIdLongArray) {
 454             if (idsNotToGetStringBuilder.length() == 0) {  // This is the first number, so only add the number.
 455                 idsNotToGetStringBuilder.append(databaseIdLong);
 456             } else {  // This is not the first number, so place a `,` before the new number.
 457                 idsNotToGetStringBuilder.append(",");
 458                 idsNotToGetStringBuilder.append(databaseIdLong);
 459             }
 460         }
 461
 462         // SQL escape `folderName`.
 463         folderName = DatabaseUtils.sqlEscapeString(folderName);
 464
 465         // Prepare the SQL statement to select all items except those with the specified IDs.
 466         String GET_BOOKMARKS_EXCEPT_SPECIFIED = "SELECT * FROM " + BOOKMARKS_TABLE +
 467                 " WHERE " + PARENT_FOLDER + " = " + folderName +
 468                 " AND " + _ID + " NOT IN (" + idsNotToGetStringBuilder.toString() +
 469                 ") ORDER BY " + DISPLAY_ORDER + " ASC";
 470
 471         // Return the results as a cursor.  The cursor cannot be closed because it will be used in the parent activity.
 472         return bookmarksDatabase.rawQuery(GET_BOOKMARKS_EXCEPT_SPECIFIED, null);
 473     }
 474
 475     // Check if a database ID is a folder.
 476     public boolean isFolder(int databaseId) {
 477         // Get a readable database handle.
 478         SQLiteDatabase bookmarksDatabase = this.getReadableDatabase();
 479
 480         // Prepare the SQL statement to determine if `databaseId` is a folder.
 481         String CHECK_IF_FOLDER = "SELECT * FROM " + BOOKMARKS_TABLE +
 482                 " WHERE " + _ID + " = " + databaseId;
 483
 484         // Populate the folder cursor.
 485         Cursor folderCursor = bookmarksDatabase.rawQuery(CHECK_IF_FOLDER, null);
 486
 487         // Ascertain if this database ID is a folder.
 488         folderCursor.moveToFirst();
 489         boolean isFolder = (folderCursor.getInt(folderCursor.getColumnIndex(IS_FOLDER)) == 1);
 490
 491         // Close the cursor and the database handle.
 492         folderCursor.close();
 493         bookmarksDatabase.close();
 494
 495         return isFolder;
 496     }
 497
 498     // Update the bookmark name and URL.
 499     public void updateBookmark(int databaseId, String bookmarkName, String bookmarkUrl) {
 500         // Initialize a ContentValues.
 501         ContentValues bookmarkContentValues = new ContentValues();
 502
 503         // Store the updated values.
 504         bookmarkContentValues.put(BOOKMARK_NAME, bookmarkName);
 505         bookmarkContentValues.put(BOOKMARK_URL, bookmarkUrl);
 506
 507         // Get a writable database handle.
 508         SQLiteDatabase bookmarksDatabase = this.getWritableDatabase();
 509
 510         // Update the bookmark.  The last argument is `null` because there are no `whereArgs`.
 511         bookmarksDatabase.update(BOOKMARKS_TABLE, bookmarkContentValues, _ID + " = " + databaseId, null);
 512
 513         // Close the database handle.
 514         bookmarksDatabase.close();
 515     }
 516
 517     // Update the bookmark name, URL, parent folder, and display order.
 518     public void updateBookmark(int databaseId, String bookmarkName, String bookmarkUrl, String parentFolder, int displayOrder) {
 519         // Initialize a `ContentValues`.
 520         ContentValues bookmarkContentValues = new ContentValues();
 521
 522         // Store the updated values.
 523         bookmarkContentValues.put(BOOKMARK_NAME, bookmarkName);
 524         bookmarkContentValues.put(BOOKMARK_URL, bookmarkUrl);
 525         bookmarkContentValues.put(PARENT_FOLDER, parentFolder);
 526         bookmarkContentValues.put(DISPLAY_ORDER, displayOrder);
 527
 528         // Get a writable database handle.
 529         SQLiteDatabase bookmarksDatabase = this.getWritableDatabase();
 530
 531         // Update the bookmark.  The last argument is `null` because there are no `whereArgs`.
 532         bookmarksDatabase.update(BOOKMARKS_TABLE, bookmarkContentValues, _ID + " = " + databaseId, null);
 533
 534         // Close the database handle.
 535         bookmarksDatabase.close();
 536     }
 537
 538     // Update the bookmark name, URL, and favorite icon.
 539     public void updateBookmark(int databaseId, String bookmarkName, String bookmarkUrl, byte[] favoriteIcon) {
 540         // Initialize a `ContentValues`.
 541         ContentValues bookmarkContentValues = new ContentValues();
 542
 543         // Store the updated values.
 544         bookmarkContentValues.put(BOOKMARK_NAME, bookmarkName);
 545         bookmarkContentValues.put(BOOKMARK_URL, bookmarkUrl);
 546         bookmarkContentValues.put(FAVORITE_ICON, favoriteIcon);
 547
 548         // Get a writable database handle.
 549         SQLiteDatabase bookmarksDatabase = this.getWritableDatabase();
 550
 551         // Update the bookmark.  The last argument is `null` because there are no `whereArgs`.
 552         bookmarksDatabase.update(BOOKMARKS_TABLE, bookmarkContentValues, _ID + " = " + databaseId, null);
 553
 554         // Close the database handle.
 555         bookmarksDatabase.close();
 556     }
 557
 558     // Update the bookmark name, URL, parent folder, display order, and favorite icon.
 559     public void updateBookmark(int databaseId, String bookmarkName, String bookmarkUrl, String parentFolder, int displayOrder, byte[] favoriteIcon) {
 560         // Initialize a `ContentValues`.
 561         ContentValues bookmarkContentValues = new ContentValues();
 562
 563         // Store the updated values.
 564         bookmarkContentValues.put(BOOKMARK_NAME, bookmarkName);
 565         bookmarkContentValues.put(BOOKMARK_URL, bookmarkUrl);
 566         bookmarkContentValues.put(PARENT_FOLDER, parentFolder);
 567         bookmarkContentValues.put(DISPLAY_ORDER, displayOrder);
 568         bookmarkContentValues.put(FAVORITE_ICON, favoriteIcon);
 569
 570         // Get a writable database handle.
 571         SQLiteDatabase bookmarksDatabase = this.getWritableDatabase();
 572
 573         // Update the bookmark.  The last argument is `null` because there are no `whereArgs`.
 574         bookmarksDatabase.update(BOOKMARKS_TABLE, bookmarkContentValues, _ID + " = " + databaseId, null);
 575
 576         // Close the database handle.
 577         bookmarksDatabase.close();
 578     }
 579
 580     // Update the folder name.
 581     public void updateFolder(int databaseId, String oldFolderName, String newFolderName) {
 582         // Get a writable database handle.
 583         SQLiteDatabase bookmarksDatabase = this.getWritableDatabase();
 584
 585         // Update the folder first.  Store the new folder name in `folderContentValues`.
 586         ContentValues folderContentValues = new ContentValues();
 587         folderContentValues.put(BOOKMARK_NAME, newFolderName);
 588
 589         // Run the update on the folder.  The last argument is `null` because there are no `whereArgs`.
 590         bookmarksDatabase.update(BOOKMARKS_TABLE, folderContentValues, _ID + " = " + databaseId, null);
 591
 592         // Update the bookmarks inside the folder.  Store the new parent folder name in `bookmarkContentValues`.
 593         ContentValues bookmarkContentValues = new ContentValues();
 594         bookmarkContentValues.put(PARENT_FOLDER, newFolderName);
 595
 596         // SQL escape `oldFolderName`.
 597         oldFolderName = DatabaseUtils.sqlEscapeString(oldFolderName);
 598
 599         // Run the update on all the bookmarks that currently list `oldFolderName` as their parent folder.  The last argument is `null` because there are no `whereArgs`.
 600         bookmarksDatabase.update(BOOKMARKS_TABLE, bookmarkContentValues, PARENT_FOLDER + " = " + oldFolderName, null);
 601
 602         // Close the database handle.
 603         bookmarksDatabase.close();
 604     }
 605
 606     // Update the folder icon.
 607     public void updateFolder(int databaseId, byte[] folderIcon) {
 608         // Get a writable database handle.
 609         SQLiteDatabase bookmarksDatabase = this.getWritableDatabase();
 610
 611         // Store the updated icon in `folderContentValues`.
 612         ContentValues folderContentValues = new ContentValues();
 613         folderContentValues.put(FAVORITE_ICON, folderIcon);
 614
 615         // Run the update on the folder.  The last argument is `null` because there are no `whereArgs`.
 616         bookmarksDatabase.update(BOOKMARKS_TABLE, folderContentValues, _ID + " = " + databaseId, null);
 617
 618         // Close the database handle.
 619         bookmarksDatabase.close();
 620     }
 621
 622     // Update the folder name, parent folder, and display order.
 623     public void updateFolder(int databaseId, String oldFolderName, String newFolderName, String parentFolder, int displayOrder) {
 624         // Get a writable database handle.
 625         SQLiteDatabase bookmarksDatabase = this.getWritableDatabase();
 626
 627         // Update the folder first.  Store the new folder name in `folderContentValues`.
 628         ContentValues folderContentValues = new ContentValues();
 629         folderContentValues.put(BOOKMARK_NAME, newFolderName);
 630         folderContentValues.put(PARENT_FOLDER, parentFolder);
 631         folderContentValues.put(DISPLAY_ORDER, displayOrder);
 632
 633         // Run the update on the folder.  The last argument is `null` because there are no `whereArgs`.
 634         bookmarksDatabase.update(BOOKMARKS_TABLE, folderContentValues, _ID + " = " + databaseId, null);
 635
 636         // Update the bookmarks inside the folder.  Store the new parent folder name in `bookmarkContentValues`.
 637         ContentValues bookmarkContentValues = new ContentValues();
 638         bookmarkContentValues.put(PARENT_FOLDER, newFolderName);
 639
 640         // SQL escape `oldFolderName`.
 641         oldFolderName = DatabaseUtils.sqlEscapeString(oldFolderName);
 642
 643         // Run the update on all the bookmarks that currently list `oldFolderName` as their parent folder.  The last argument is `null` because there are no `whereArgs`.
 644         bookmarksDatabase.update(BOOKMARKS_TABLE, bookmarkContentValues, PARENT_FOLDER + " = " + oldFolderName, null);
 645
 646         // Close the database handle.
 647         bookmarksDatabase.close();
 648     }
 649
 650     // Update the folder name and icon.
 651     public void updateFolder(int databaseId, String oldFolderName, String newFolderName, byte[] folderIcon) {
 652         // Get a writable database handle.
 653         SQLiteDatabase bookmarksDatabase = this.getWritableDatabase();
 654
 655         // Update the folder first.  Store the updated values in `folderContentValues`.
 656         ContentValues folderContentValues = new ContentValues();
 657         folderContentValues.put(BOOKMARK_NAME, newFolderName);
 658         folderContentValues.put(FAVORITE_ICON, folderIcon);
 659
 660         // Run the update on the folder.  The last argument is `null` because there are no `whereArgs`.
 661         bookmarksDatabase.update(BOOKMARKS_TABLE, folderContentValues, _ID + " = " + databaseId, null);
 662
 663         // Update the bookmarks inside the folder.  Store the new parent folder name in `bookmarkContentValues`.
 664         ContentValues bookmarkContentValues = new ContentValues();
 665         bookmarkContentValues.put(PARENT_FOLDER, newFolderName);
 666
 667         // SQL escape `oldFolderName`.
 668         oldFolderName = DatabaseUtils.sqlEscapeString(oldFolderName);
 669
 670         // Run the update on all the bookmarks that currently list `oldFolderName` as their parent folder.  The last argument is `null` because there are no `whereArgs`.
 671         bookmarksDatabase.update(BOOKMARKS_TABLE, bookmarkContentValues, PARENT_FOLDER + " = " + oldFolderName, null);
 672
 673         // Close the database handle.
 674         bookmarksDatabase.close();
 675     }
 676
 677     // Update the folder name and icon.
 678     public void updateFolder(int databaseId, String oldFolderName, String newFolderName, String parentFolder, int displayOrder, byte[] folderIcon) {
 679         // Get a writable database handle.
 680         SQLiteDatabase bookmarksDatabase = this.getWritableDatabase();
 681
 682         // Update the folder first.  Store the updated values in `folderContentValues`.
 683         ContentValues folderContentValues = new ContentValues();
 684         folderContentValues.put(BOOKMARK_NAME, newFolderName);
 685         folderContentValues.put(PARENT_FOLDER, parentFolder);
 686         folderContentValues.put(DISPLAY_ORDER, displayOrder);
 687         folderContentValues.put(FAVORITE_ICON, folderIcon);
 688
 689         // Run the update on the folder.  The last argument is `null` because there are no `whereArgs`.
 690         bookmarksDatabase.update(BOOKMARKS_TABLE, folderContentValues, _ID + " = " + databaseId, null);
 691
 692         // Update the bookmarks inside the folder.  Store the new parent folder name in `bookmarkContentValues`.
 693         ContentValues bookmarkContentValues = new ContentValues();
 694         bookmarkContentValues.put(PARENT_FOLDER, newFolderName);
 695
 696         // SQL escape `oldFolderName`.
 697         oldFolderName = DatabaseUtils.sqlEscapeString(oldFolderName);
 698
 699         // Run the update on all the bookmarks that currently list `oldFolderName` as their parent folder.  The last argument is `null` because there are no `whereArgs`.
 700         bookmarksDatabase.update(BOOKMARKS_TABLE, bookmarkContentValues, PARENT_FOLDER + " = " + oldFolderName, null);
 701
 702         // Close the database handle.
 703         bookmarksDatabase.close();
 704     }
 705
 706     // Update the display order for one bookmark or folder.
 707     public void updateDisplayOrder(int databaseId, int displayOrder) {
 708         // Get a writable database handle.
 709         SQLiteDatabase bookmarksDatabase = this.getWritableDatabase();
 710
 711         // Store the new display order in `bookmarkContentValues`.
 712         ContentValues bookmarkContentValues = new ContentValues();
 713         bookmarkContentValues.put(DISPLAY_ORDER, displayOrder);
 714
 715         // Update the database.  The last argument is `null` because there are no `whereArgs`.
 716         bookmarksDatabase.update(BOOKMARKS_TABLE, bookmarkContentValues, _ID + " = " + databaseId, null);
 717
 718         // Close the database handle.
 719         bookmarksDatabase.close();
 720     }
 721
 722     // Move one bookmark or folder to a new folder.
 723     public void moveToFolder(int databaseId, String newFolder) {
 724         // Get a writable database handle.
 725         SQLiteDatabase bookmarksDatabase = this.getWritableDatabase();
 726
 727         // SQL escape the new folder name.
 728         String newFolderSqlEscaped = DatabaseUtils.sqlEscapeString(newFolder);
 729
 730         // Prepare a SQL query to select all the bookmarks in the new folder.
 731         String NEW_FOLDER = "SELECT * FROM " + BOOKMARKS_TABLE +
 732                 " WHERE " + PARENT_FOLDER + " = " + newFolderSqlEscaped +
 733                 " ORDER BY " + DISPLAY_ORDER + " ASC";
 734
 735         // Get a cursor for all the bookmarks in the new folder.  The second argument is `null` because there are no `selectionArgs`.
 736         Cursor newFolderCursor = bookmarksDatabase.rawQuery(NEW_FOLDER, null);
 737
 738         // Instantiate a variable to store the display order after the move.
 739         int displayOrder;
 740
 741         // Set the new display order.
 742         if (newFolderCursor.getCount() > 0) {  // There are already bookmarks in the folder.
 743             // Move to the last bookmark.
 744             newFolderCursor.moveToLast();
 745
 746             // Set the display order to be one greater that the last bookmark.
 747             displayOrder = newFolderCursor.getInt(newFolderCursor.getColumnIndex(DISPLAY_ORDER)) + 1;
 748         } else {  // There are no bookmarks in the new folder.
 749             // Set the display order to be `0`.
 750             displayOrder = 0;
 751         }
 752
 753         // Close the new folder `Cursor`.
 754         newFolderCursor.close();
 755
 756         // Store the new values in `bookmarkContentValues`.
 757         ContentValues bookmarkContentValues = new ContentValues();
 758         bookmarkContentValues.put(DISPLAY_ORDER, displayOrder);
 759         bookmarkContentValues.put(PARENT_FOLDER, newFolder);
 760
 761         // Update the database.  The last argument is `null` because there are no `whereArgs`.
 762         bookmarksDatabase.update(BOOKMARKS_TABLE, bookmarkContentValues, _ID + " = " + databaseId, null);
 763
 764         // Close the database handle.
 765         bookmarksDatabase.close();
 766     }
 767
 768     // Delete one bookmark.
 769     public void deleteBookmark(int databaseId) {
 770         // Get a writable database handle.
 771         SQLiteDatabase bookmarksDatabase = this.getWritableDatabase();
 772
 773         // Deletes the row with the given `databaseId`.  The last argument is `null` because we don't need additional parameters.
 774         bookmarksDatabase.delete(BOOKMARKS_TABLE, _ID + " = " + databaseId, null);
 775
 776         // Close the database handle.
 777         bookmarksDatabase.close();
 778     }
 779 }