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 cursor cannot be closed because it is used in the parent activity.
 299         return bookmarksDatabase.rawQuery(GET_ALL_FOLDERS, null);
 300     }
 301
 302     // Get a cursor for all bookmarks and folders.
 303     public Cursor getAllBookmarks() {
 304         // Get a readable database handle.
 305         SQLiteDatabase bookmarksDatabase = this.getReadableDatabase();
 306
 307         // Get everything in the bookmarks table.
 308         String GET_ALL_BOOKMARKS = "SELECT * FROM " + BOOKMARKS_TABLE;
 309
 310         // Return the result as a Cursor.  The Cursor cannot be closed because it is used in the parent activity.
 311         return bookmarksDatabase.rawQuery(GET_ALL_BOOKMARKS, null);
 312     }
 313
 314     // Get a cursor for all bookmarks and folders ordered by display order.
 315     public Cursor getAllBookmarksByDisplayOrder() {
 316         // Get a readable database handle.
 317         SQLiteDatabase bookmarksDatabase = this.getReadableDatabase();
 318
 319         // Get everything in the bookmarks table ordered by display order.
 320         String GET_ALL_BOOKMARKS = "SELECT * FROM " + BOOKMARKS_TABLE +
 321                 " ORDER BY " + DISPLAY_ORDER + " ASC";
 322
 323         // Return the result as a cursor.  The cursor cannot be closed because it is used in the parent activity.
 324         return bookmarksDatabase.rawQuery(GET_ALL_BOOKMARKS, null);
 325     }
 326
 327     // Get a cursor for all bookmarks and folders except those with the specified IDs.
 328     public Cursor getAllBookmarksExcept(long[] exceptIdLongArray) {
 329         // Get a readable database handle.
 330         SQLiteDatabase bookmarksDatabase = this.getReadableDatabase();
 331
 332         // Prepare a string builder to contain the comma-separated list of IDs not to get.
 333         StringBuilder idsNotToGetStringBuilder = new StringBuilder();
 334
 335         // Extract the array of IDs not to get to the string builder.
 336         for (long databaseIdLong : exceptIdLongArray) {
 337             if (idsNotToGetStringBuilder.length() == 0) {  // This is the first number, so only add the number.
 338                 idsNotToGetStringBuilder.append(databaseIdLong);
 339             } else {  // This is not the first number, so place a `,` before the new number.
 340                 idsNotToGetStringBuilder.append(",");
 341                 idsNotToGetStringBuilder.append(databaseIdLong);
 342             }
 343         }
 344
 345         // Prepare the SQL statement to select all items except those with the specified IDs.
 346         String GET_ALL_BOOKMARKS_EXCEPT_SPECIFIED = "SELECT * FROM " + BOOKMARKS_TABLE +
 347                 " WHERE " + _ID + " NOT IN (" + idsNotToGetStringBuilder.toString() + ")";
 348
 349         // Return the results as a cursor.  The cursor cannot be closed because it will be used in the parent activity.
 350         return bookmarksDatabase.rawQuery(GET_ALL_BOOKMARKS_EXCEPT_SPECIFIED, null);
 351     }
 352
 353     // Get a cursor for all bookmarks and folders by display order except for a specific of IDs.
 354     public Cursor getAllBookmarksByDisplayOrderExcept(long[] exceptIdLongArray) {
 355         // Get a readable database handle.
 356         SQLiteDatabase bookmarksDatabase = this.getReadableDatabase();
 357
 358         // Prepare a string builder to contain the comma-separated list of IDs not to get.
 359         StringBuilder idsNotToGetStringBuilder = new StringBuilder();
 360
 361         // Extract the array of IDs not to get to the string builder.
 362         for (long databaseIdLong : exceptIdLongArray) {
 363             if (idsNotToGetStringBuilder.length() == 0) {  // This is the first number, so only add the number.
 364                 idsNotToGetStringBuilder.append(databaseIdLong);
 365             } else {  // This is not the first number, so place a `,` before the new number.
 366                 idsNotToGetStringBuilder.append(",");
 367                 idsNotToGetStringBuilder.append(databaseIdLong);
 368             }
 369         }
 370
 371         // Prepare the SQL statement to select all items except those with the specified IDs.
 372         String GET_ALL_BOOKMARKS_EXCEPT_SPECIFIED = "SELECT * FROM " + BOOKMARKS_TABLE +
 373                 " WHERE " + _ID + " NOT IN (" + idsNotToGetStringBuilder.toString() +
 374                 ") ORDER BY " + DISPLAY_ORDER + " ASC";
 375
 376         // Return the results as a cursor.  The cursor cannot be closed because it will be used in the parent activity.
 377         return bookmarksDatabase.rawQuery(GET_ALL_BOOKMARKS_EXCEPT_SPECIFIED, null);
 378     }
 379
 380     // Get a cursor for bookmarks and folders in the specified folder.
 381     public Cursor getBookmarks(String folderName) {
 382         // Get a readable database handle.
 383         SQLiteDatabase bookmarksDatabase = this.getReadableDatabase();
 384
 385         // SQL escape the folder name.
 386         folderName = DatabaseUtils.sqlEscapeString(folderName);
 387
 388         // Get everything in the bookmarks table with `folderName` as the `PARENT_FOLDER`.
 389         String GET_BOOKMARKS = "SELECT * FROM " + BOOKMARKS_TABLE +
 390                 " WHERE " + PARENT_FOLDER + " = " + folderName;
 391
 392         // Return the result as a cursor.  The cursor cannot be closed because it is used in the parent activity.
 393         return bookmarksDatabase.rawQuery(GET_BOOKMARKS, null);
 394     }
 395
 396     // Get a cursor for bookmarks and folders in the specified folder ordered by display order.
 397     public Cursor getBookmarksByDisplayOrder(String folderName) {
 398         // Get a readable database handle.
 399         SQLiteDatabase bookmarksDatabase = this.getReadableDatabase();
 400
 401         // SQL escape `folderName`.
 402         folderName = DatabaseUtils.sqlEscapeString(folderName);
 403
 404         // Get everything in the bookmarks table with `folderName` as the `PARENT_FOLDER`.
 405         String GET_BOOKMARKS = "SELECT * FROM " + BOOKMARKS_TABLE +
 406                 " WHERE " + PARENT_FOLDER + " = " + folderName +
 407                 " ORDER BY " + DISPLAY_ORDER + " ASC";
 408
 409         // Return the result as a cursor.  The cursor cannot be closed because it is used in the parent activity.
 410         return bookmarksDatabase.rawQuery(GET_BOOKMARKS, null);
 411     }
 412
 413     // Get a cursor for bookmarks and folders in the specified folder except for ta specific list of IDs.
 414     public Cursor getBookmarksExcept(long[] exceptIdLongArray, String folderName) {
 415         // Get a readable database handle.
 416         SQLiteDatabase bookmarksDatabase = this.getReadableDatabase();
 417
 418         // Prepare a string builder to contain the comma-separated list of IDs not to get.
 419         StringBuilder idsNotToGetStringBuilder = new StringBuilder();
 420
 421         // Extract the array of IDs not to get to the string builder.
 422         for (long databaseIdLong : exceptIdLongArray) {
 423             if (idsNotToGetStringBuilder.length() == 0) {  // This is the first number, so only add the number.
 424                 idsNotToGetStringBuilder.append(databaseIdLong);
 425             } else {  // This is not the first number, so place a `,` before the new number.
 426                 idsNotToGetStringBuilder.append(",");
 427                 idsNotToGetStringBuilder.append(databaseIdLong);
 428             }
 429         }
 430
 431         // SQL escape the folder name.
 432         folderName = DatabaseUtils.sqlEscapeString(folderName);
 433
 434         // Get everything in the bookmarks table with `folderName` as the `PARENT_FOLDER` except those with the specified IDs.
 435         String GET_BOOKMARKS_EXCEPT_SPECIFIED = "SELECT * FROM " + BOOKMARKS_TABLE +
 436                 " WHERE " + PARENT_FOLDER + " = " + folderName +
 437                 " AND " + _ID + " NOT IN (" + idsNotToGetStringBuilder.toString() + ")";
 438
 439         // Return the result as a cursor.  The cursor cannot be closed because it is used in the parent activity.
 440         return bookmarksDatabase.rawQuery(GET_BOOKMARKS_EXCEPT_SPECIFIED, null);
 441     }
 442
 443     // Get a cursor for bookmarks and folders in the specified folder by display order except for a specific list of IDs.
 444     public Cursor getBookmarksByDisplayOrderExcept(long[] exceptIdLongArray, String folderName) {
 445         // Get a readable database handle.
 446         SQLiteDatabase bookmarksDatabase = this.getReadableDatabase();
 447
 448         // Prepare a string builder to contain the comma-separated list of IDs not to get.
 449         StringBuilder idsNotToGetStringBuilder = new StringBuilder();
 450
 451         // Extract the array of IDs not to get to the string builder.
 452         for (long databaseIdLong : exceptIdLongArray) {
 453             if (idsNotToGetStringBuilder.length() == 0) {  // This is the first number, so only add the number.
 454                 idsNotToGetStringBuilder.append(databaseIdLong);
 455             } else {  // This is not the first number, so place a `,` before the new number.
 456                 idsNotToGetStringBuilder.append(",");
 457                 idsNotToGetStringBuilder.append(databaseIdLong);
 458             }
 459         }
 460
 461         // SQL escape `folderName`.
 462         folderName = DatabaseUtils.sqlEscapeString(folderName);
 463
 464         // Prepare the SQL statement to select all items except those with the specified IDs.
 465         String GET_BOOKMARKS_EXCEPT_SPECIFIED = "SELECT * FROM " + BOOKMARKS_TABLE +
 466                 " WHERE " + PARENT_FOLDER + " = " + folderName +
 467                 " AND " + _ID + " NOT IN (" + idsNotToGetStringBuilder.toString() +
 468                 ") ORDER BY " + DISPLAY_ORDER + " ASC";
 469
 470         // Return the results as a cursor.  The cursor cannot be closed because it will be used in the parent activity.
 471         return bookmarksDatabase.rawQuery(GET_BOOKMARKS_EXCEPT_SPECIFIED, null);
 472     }
 473
 474     // Check if a database ID is a folder.
 475     public boolean isFolder(int databaseId) {
 476         // Get a readable database handle.
 477         SQLiteDatabase bookmarksDatabase = this.getReadableDatabase();
 478
 479         // Prepare the SQL statement to determine if `databaseId` is a folder.
 480         String CHECK_IF_FOLDER = "SELECT * FROM " + BOOKMARKS_TABLE +
 481                 " WHERE " + _ID + " = " + databaseId;
 482
 483         // Populate the folder cursor.
 484         Cursor folderCursor = bookmarksDatabase.rawQuery(CHECK_IF_FOLDER, null);
 485
 486         // Ascertain if this database ID is a folder.
 487         folderCursor.moveToFirst();
 488         boolean isFolder = (folderCursor.getInt(folderCursor.getColumnIndex(IS_FOLDER)) == 1);
 489
 490         // Close the cursor and the database handle.
 491         folderCursor.close();
 492         bookmarksDatabase.close();
 493
 494         return isFolder;
 495     }
 496
 497     // Update the bookmark name and URL.
 498     public void updateBookmark(int databaseId, String bookmarkName, String bookmarkUrl) {
 499         // Initialize a ContentValues.
 500         ContentValues bookmarkContentValues = new ContentValues();
 501
 502         // Store the updated values.
 503         bookmarkContentValues.put(BOOKMARK_NAME, bookmarkName);
 504         bookmarkContentValues.put(BOOKMARK_URL, bookmarkUrl);
 505
 506         // Get a writable database handle.
 507         SQLiteDatabase bookmarksDatabase = this.getWritableDatabase();
 508
 509         // Update the bookmark.  The last argument is `null` because there are no `whereArgs`.
 510         bookmarksDatabase.update(BOOKMARKS_TABLE, bookmarkContentValues, _ID + " = " + databaseId, null);
 511
 512         // Close the database handle.
 513         bookmarksDatabase.close();
 514     }
 515
 516     // Update the bookmark name, URL, parent folder, and display order.
 517     public void updateBookmark(int databaseId, String bookmarkName, String bookmarkUrl, String parentFolder, int displayOrder) {
 518         // Initialize a `ContentValues`.
 519         ContentValues bookmarkContentValues = new ContentValues();
 520
 521         // Store the updated values.
 522         bookmarkContentValues.put(BOOKMARK_NAME, bookmarkName);
 523         bookmarkContentValues.put(BOOKMARK_URL, bookmarkUrl);
 524         bookmarkContentValues.put(PARENT_FOLDER, parentFolder);
 525         bookmarkContentValues.put(DISPLAY_ORDER, displayOrder);
 526
 527         // Get a writable database handle.
 528         SQLiteDatabase bookmarksDatabase = this.getWritableDatabase();
 529
 530         // Update the bookmark.  The last argument is `null` because there are no `whereArgs`.
 531         bookmarksDatabase.update(BOOKMARKS_TABLE, bookmarkContentValues, _ID + " = " + databaseId, null);
 532
 533         // Close the database handle.
 534         bookmarksDatabase.close();
 535     }
 536
 537     // Update the bookmark name, URL, and favorite icon.
 538     public void updateBookmark(int databaseId, String bookmarkName, String bookmarkUrl, byte[] favoriteIcon) {
 539         // Initialize a `ContentValues`.
 540         ContentValues bookmarkContentValues = new ContentValues();
 541
 542         // Store the updated values.
 543         bookmarkContentValues.put(BOOKMARK_NAME, bookmarkName);
 544         bookmarkContentValues.put(BOOKMARK_URL, bookmarkUrl);
 545         bookmarkContentValues.put(FAVORITE_ICON, favoriteIcon);
 546
 547         // Get a writable database handle.
 548         SQLiteDatabase bookmarksDatabase = this.getWritableDatabase();
 549
 550         // Update the bookmark.  The last argument is `null` because there are no `whereArgs`.
 551         bookmarksDatabase.update(BOOKMARKS_TABLE, bookmarkContentValues, _ID + " = " + databaseId, null);
 552
 553         // Close the database handle.
 554         bookmarksDatabase.close();
 555     }
 556
 557     // Update the bookmark name, URL, parent folder, display order, and favorite icon.
 558     public void updateBookmark(int databaseId, String bookmarkName, String bookmarkUrl, String parentFolder, int displayOrder, byte[] favoriteIcon) {
 559         // Initialize a `ContentValues`.
 560         ContentValues bookmarkContentValues = new ContentValues();
 561
 562         // Store the updated values.
 563         bookmarkContentValues.put(BOOKMARK_NAME, bookmarkName);
 564         bookmarkContentValues.put(BOOKMARK_URL, bookmarkUrl);
 565         bookmarkContentValues.put(PARENT_FOLDER, parentFolder);
 566         bookmarkContentValues.put(DISPLAY_ORDER, displayOrder);
 567         bookmarkContentValues.put(FAVORITE_ICON, favoriteIcon);
 568
 569         // Get a writable database handle.
 570         SQLiteDatabase bookmarksDatabase = this.getWritableDatabase();
 571
 572         // Update the bookmark.  The last argument is `null` because there are no `whereArgs`.
 573         bookmarksDatabase.update(BOOKMARKS_TABLE, bookmarkContentValues, _ID + " = " + databaseId, null);
 574
 575         // Close the database handle.
 576         bookmarksDatabase.close();
 577     }
 578
 579     // Update the folder name.
 580     public void updateFolder(int databaseId, String oldFolderName, String newFolderName) {
 581         // Get a writable database handle.
 582         SQLiteDatabase bookmarksDatabase = this.getWritableDatabase();
 583
 584         // Update the folder first.  Store the new folder name in `folderContentValues`.
 585         ContentValues folderContentValues = new ContentValues();
 586         folderContentValues.put(BOOKMARK_NAME, newFolderName);
 587
 588         // Run the update on the folder.  The last argument is `null` because there are no `whereArgs`.
 589         bookmarksDatabase.update(BOOKMARKS_TABLE, folderContentValues, _ID + " = " + databaseId, null);
 590
 591         // Update the bookmarks inside the folder.  Store the new parent folder name in `bookmarkContentValues`.
 592         ContentValues bookmarkContentValues = new ContentValues();
 593         bookmarkContentValues.put(PARENT_FOLDER, newFolderName);
 594
 595         // SQL escape `oldFolderName`.
 596         oldFolderName = DatabaseUtils.sqlEscapeString(oldFolderName);
 597
 598         // 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`.
 599         bookmarksDatabase.update(BOOKMARKS_TABLE, bookmarkContentValues, PARENT_FOLDER + " = " + oldFolderName, null);
 600
 601         // Close the database handle.
 602         bookmarksDatabase.close();
 603     }
 604
 605     // Update the folder icon.
 606     public void updateFolder(int databaseId, byte[] folderIcon) {
 607         // Get a writable database handle.
 608         SQLiteDatabase bookmarksDatabase = this.getWritableDatabase();
 609
 610         // Store the updated icon in `folderContentValues`.
 611         ContentValues folderContentValues = new ContentValues();
 612         folderContentValues.put(FAVORITE_ICON, folderIcon);
 613
 614         // Run the update on the folder.  The last argument is `null` because there are no `whereArgs`.
 615         bookmarksDatabase.update(BOOKMARKS_TABLE, folderContentValues, _ID + " = " + databaseId, null);
 616
 617         // Close the database handle.
 618         bookmarksDatabase.close();
 619     }
 620
 621     // Update the folder name, parent folder, and display order.
 622     public void updateFolder(int databaseId, String oldFolderName, String newFolderName, String parentFolder, int displayOrder) {
 623         // Get a writable database handle.
 624         SQLiteDatabase bookmarksDatabase = this.getWritableDatabase();
 625
 626         // Update the folder first.  Store the new folder name in `folderContentValues`.
 627         ContentValues folderContentValues = new ContentValues();
 628         folderContentValues.put(BOOKMARK_NAME, newFolderName);
 629         folderContentValues.put(PARENT_FOLDER, parentFolder);
 630         folderContentValues.put(DISPLAY_ORDER, displayOrder);
 631
 632         // Run the update on the folder.  The last argument is `null` because there are no `whereArgs`.
 633         bookmarksDatabase.update(BOOKMARKS_TABLE, folderContentValues, _ID + " = " + databaseId, null);
 634
 635         // Update the bookmarks inside the folder.  Store the new parent folder name in `bookmarkContentValues`.
 636         ContentValues bookmarkContentValues = new ContentValues();
 637         bookmarkContentValues.put(PARENT_FOLDER, newFolderName);
 638
 639         // SQL escape `oldFolderName`.
 640         oldFolderName = DatabaseUtils.sqlEscapeString(oldFolderName);
 641
 642         // 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`.
 643         bookmarksDatabase.update(BOOKMARKS_TABLE, bookmarkContentValues, PARENT_FOLDER + " = " + oldFolderName, null);
 644
 645         // Close the database handle.
 646         bookmarksDatabase.close();
 647     }
 648
 649     // Update the folder name and icon.
 650     public void updateFolder(int databaseId, String oldFolderName, String newFolderName, byte[] folderIcon) {
 651         // Get a writable database handle.
 652         SQLiteDatabase bookmarksDatabase = this.getWritableDatabase();
 653
 654         // Update the folder first.  Store the updated values in `folderContentValues`.
 655         ContentValues folderContentValues = new ContentValues();
 656         folderContentValues.put(BOOKMARK_NAME, newFolderName);
 657         folderContentValues.put(FAVORITE_ICON, folderIcon);
 658
 659         // Run the update on the folder.  The last argument is `null` because there are no `whereArgs`.
 660         bookmarksDatabase.update(BOOKMARKS_TABLE, folderContentValues, _ID + " = " + databaseId, null);
 661
 662         // Update the bookmarks inside the folder.  Store the new parent folder name in `bookmarkContentValues`.
 663         ContentValues bookmarkContentValues = new ContentValues();
 664         bookmarkContentValues.put(PARENT_FOLDER, newFolderName);
 665
 666         // SQL escape `oldFolderName`.
 667         oldFolderName = DatabaseUtils.sqlEscapeString(oldFolderName);
 668
 669         // 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`.
 670         bookmarksDatabase.update(BOOKMARKS_TABLE, bookmarkContentValues, PARENT_FOLDER + " = " + oldFolderName, null);
 671
 672         // Close the database handle.
 673         bookmarksDatabase.close();
 674     }
 675
 676     // Update the folder name and icon.
 677     public void updateFolder(int databaseId, String oldFolderName, String newFolderName, String parentFolder, int displayOrder, byte[] folderIcon) {
 678         // Get a writable database handle.
 679         SQLiteDatabase bookmarksDatabase = this.getWritableDatabase();
 680
 681         // Update the folder first.  Store the updated values in `folderContentValues`.
 682         ContentValues folderContentValues = new ContentValues();
 683         folderContentValues.put(BOOKMARK_NAME, newFolderName);
 684         folderContentValues.put(PARENT_FOLDER, parentFolder);
 685         folderContentValues.put(DISPLAY_ORDER, displayOrder);
 686         folderContentValues.put(FAVORITE_ICON, folderIcon);
 687
 688         // Run the update on the folder.  The last argument is `null` because there are no `whereArgs`.
 689         bookmarksDatabase.update(BOOKMARKS_TABLE, folderContentValues, _ID + " = " + databaseId, null);
 690
 691         // Update the bookmarks inside the folder.  Store the new parent folder name in `bookmarkContentValues`.
 692         ContentValues bookmarkContentValues = new ContentValues();
 693         bookmarkContentValues.put(PARENT_FOLDER, newFolderName);
 694
 695         // SQL escape `oldFolderName`.
 696         oldFolderName = DatabaseUtils.sqlEscapeString(oldFolderName);
 697
 698         // 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`.
 699         bookmarksDatabase.update(BOOKMARKS_TABLE, bookmarkContentValues, PARENT_FOLDER + " = " + oldFolderName, null);
 700
 701         // Close the database handle.
 702         bookmarksDatabase.close();
 703     }
 704
 705     // Update the display order for one bookmark or folder.
 706     public void updateDisplayOrder(int databaseId, int displayOrder) {
 707         // Get a writable database handle.
 708         SQLiteDatabase bookmarksDatabase = this.getWritableDatabase();
 709
 710         // Store the new display order in `bookmarkContentValues`.
 711         ContentValues bookmarkContentValues = new ContentValues();
 712         bookmarkContentValues.put(DISPLAY_ORDER, displayOrder);
 713
 714         // Update the database.  The last argument is `null` because there are no `whereArgs`.
 715         bookmarksDatabase.update(BOOKMARKS_TABLE, bookmarkContentValues, _ID + " = " + databaseId, null);
 716
 717         // Close the database handle.
 718         bookmarksDatabase.close();
 719     }
 720
 721     // Move one bookmark or folder to a new folder.
 722     public void moveToFolder(int databaseId, String newFolder) {
 723         // Get a writable database handle.
 724         SQLiteDatabase bookmarksDatabase = this.getWritableDatabase();
 725
 726         // SQL escape the new folder name.
 727         String newFolderSqlEscaped = DatabaseUtils.sqlEscapeString(newFolder);
 728
 729         // Prepare a SQL query to select all the bookmarks in the new folder.
 730         String NEW_FOLDER = "SELECT * FROM " + BOOKMARKS_TABLE +
 731                 " WHERE " + PARENT_FOLDER + " = " + newFolderSqlEscaped +
 732                 " ORDER BY " + DISPLAY_ORDER + " ASC";
 733
 734         // Get a cursor for all the bookmarks in the new folder.  The second argument is `null` because there are no `selectionArgs`.
 735         Cursor newFolderCursor = bookmarksDatabase.rawQuery(NEW_FOLDER, null);
 736
 737         // Instantiate a variable to store the display order after the move.
 738         int displayOrder;
 739
 740         // Set the new display order.
 741         if (newFolderCursor.getCount() > 0) {  // There are already bookmarks in the folder.
 742             // Move to the last bookmark.
 743             newFolderCursor.moveToLast();
 744
 745             // Set the display order to be one greater that the last bookmark.
 746             displayOrder = newFolderCursor.getInt(newFolderCursor.getColumnIndex(DISPLAY_ORDER)) + 1;
 747         } else {  // There are no bookmarks in the new folder.
 748             // Set the display order to be `0`.
 749             displayOrder = 0;
 750         }
 751
 752         // Close the new folder `Cursor`.
 753         newFolderCursor.close();
 754
 755         // Store the new values in `bookmarkContentValues`.
 756         ContentValues bookmarkContentValues = new ContentValues();
 757         bookmarkContentValues.put(DISPLAY_ORDER, displayOrder);
 758         bookmarkContentValues.put(PARENT_FOLDER, newFolder);
 759
 760         // Update the database.  The last argument is `null` because there are no `whereArgs`.
 761         bookmarksDatabase.update(BOOKMARKS_TABLE, bookmarkContentValues, _ID + " = " + databaseId, null);
 762
 763         // Close the database handle.
 764         bookmarksDatabase.close();
 765     }
 766
 767     // Delete one bookmark.
 768     public void deleteBookmark(int databaseId) {
 769         // Get a writable database handle.
 770         SQLiteDatabase bookmarksDatabase = this.getWritableDatabase();
 771
 772         // Deletes the row with the given `databaseId`.  The last argument is `null` because we don't need additional parameters.
 773         bookmarksDatabase.delete(BOOKMARKS_TABLE, _ID + " = " + databaseId, null);
 774
 775         // Close the database handle.
 776         bookmarksDatabase.close();
 777     }
 778 }