2 * Copyright © 2016-2019 Soren Stoutner <soren@stoutner.com>.
4 * This file is part of Privacy Browser <https://www.stoutner.com/privacy-browser>.
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.
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.
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/>.
20 package com.stoutner.privacybrowser.helpers;
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;
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";
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";
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)";
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);
57 public void onCreate(SQLiteDatabase bookmarksDatabase) {
58 // Create the bookmarks table.
59 bookmarksDatabase.execSQL(CREATE_BOOKMARKS_TABLE);
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.
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();
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);
80 // Get a writable database handle.
81 SQLiteDatabase bookmarksDatabase = this.getWritableDatabase();
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);
86 // Close the database handle.
87 bookmarksDatabase.close();
90 // Create a bookmark from content values.
91 void createBookmark(ContentValues contentValues) {
92 // Get a writable database.
93 SQLiteDatabase bookmarksDatabase = this.getWritableDatabase();
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);
98 // Close the database handle.
99 bookmarksDatabase.close();
103 public void createFolder(String folderName, String parentFolder, byte[] favoriteIcon) {
104 ContentValues bookmarkContentValues = new ContentValues();
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);
113 // Get a writable database handle.
114 SQLiteDatabase bookmarksDatabase = this.getWritableDatabase();
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);
119 // Close the database handle.
120 bookmarksDatabase.close();
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();
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;
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);
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();
141 // Prepare the SQL statement to get the cursor for the folder.
142 String GET_FOLDER = "SELECT * FROM " + BOOKMARKS_TABLE +
143 " WHERE " + _ID + " = " + databaseId;
145 // Get a folder cursor.
146 Cursor folderCursor = bookmarksDatabase.rawQuery(GET_FOLDER, null);
148 // Get the folder name.
149 folderCursor.moveToFirst();
150 String folderName = folderCursor.getString(folderCursor.getColumnIndex(BOOKMARK_NAME));
152 // Close the cursor and the database handle.
153 folderCursor.close();
154 bookmarksDatabase.close();
156 // Return the folder name.
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();
165 // SQL escape `folderName`.
166 folderName = DatabaseUtils.sqlEscapeString(folderName);
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;
173 // Get `folderCursor`. The second argument is `null` because there are no `selectionArgs`.
174 Cursor folderCursor = bookmarksDatabase.rawQuery(GET_FOLDER, null);
176 // Get the database ID.
177 folderCursor.moveToFirst();
178 int databaseId = folderCursor.getInt(folderCursor.getColumnIndex(_ID));
180 // Close the cursor and the database handle.
181 folderCursor.close();
182 bookmarksDatabase.close();
184 // Return the database ID.
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();
193 // SQL escape `folderName`.
194 folderName = DatabaseUtils.sqlEscapeString(folderName);
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;
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);
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();
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";
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);
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();
227 // SQL escape `currentFolder.
228 currentFolder = DatabaseUtils.sqlEscapeString(currentFolder);
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;
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);
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();
245 // SQL escape `currentFolder`.
246 currentFolder = DatabaseUtils.sqlEscapeString(currentFolder);
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;
253 // Get the bookmark cursor and move to the first entry.
254 Cursor bookmarkCursor = bookmarksDatabase.rawQuery(GET_CURRENT_FOLDER, null);
255 bookmarkCursor.moveToFirst();
257 // Store the name of the parent folder.
258 String parentFolder = bookmarkCursor.getString(bookmarkCursor.getColumnIndex(PARENT_FOLDER));
261 bookmarkCursor.close();
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();
271 // Prepare the SQL statement to get the current bookmark.
272 String GET_BOOKMARK = "SELECT * FROM " + BOOKMARKS_TABLE +
273 " WHERE " + _ID + " = " + databaseId;
275 // Get the bookmark cursor and move to the first entry.
276 Cursor bookmarkCursor = bookmarksDatabase.rawQuery(GET_BOOKMARK, null);
277 bookmarkCursor.moveToFirst();
279 // Store the name of the parent folder.
280 String parentFolder = bookmarkCursor.getString(bookmarkCursor.getColumnIndex(PARENT_FOLDER));
283 bookmarkCursor.close();
288 // Get a cursor of all the folders.
289 public Cursor getAllFolders() {
290 // Get a readable database handle.
291 SQLiteDatabase bookmarksDatabase = this.getReadableDatabase();
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";
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);
302 // Get a cursor for all bookmarks and folders.
303 public Cursor getAllBookmarks() {
304 // Get a readable database handle.
305 SQLiteDatabase bookmarksDatabase = this.getReadableDatabase();
307 // Get everything in the bookmarks table.
308 String GET_ALL_BOOKMARKS = "SELECT * FROM " + BOOKMARKS_TABLE;
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);
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();
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";
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);
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();
332 // Prepare a string builder to contain the comma-separated list of IDs not to get.
333 StringBuilder idsNotToGetStringBuilder = new StringBuilder();
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);
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() + ")";
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);
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();
358 // Prepare a string builder to contain the comma-separated list of IDs not to get.
359 StringBuilder idsNotToGetStringBuilder = new StringBuilder();
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);
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";
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);
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();
385 // SQL escape the folder name.
386 folderName = DatabaseUtils.sqlEscapeString(folderName);
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;
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);
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();
401 // SQL escape `folderName`.
402 folderName = DatabaseUtils.sqlEscapeString(folderName);
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";
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);
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();
418 // Prepare a string builder to contain the comma-separated list of IDs not to get.
419 StringBuilder idsNotToGetStringBuilder = new StringBuilder();
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);
431 // SQL escape the folder name.
432 folderName = DatabaseUtils.sqlEscapeString(folderName);
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() + ")";
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);
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();
448 // Prepare a string builder to contain the comma-separated list of IDs not to get.
449 StringBuilder idsNotToGetStringBuilder = new StringBuilder();
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);
461 // SQL escape `folderName`.
462 folderName = DatabaseUtils.sqlEscapeString(folderName);
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";
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);
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();
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;
483 // Populate the folder cursor.
484 Cursor folderCursor = bookmarksDatabase.rawQuery(CHECK_IF_FOLDER, null);
486 // Ascertain if this database ID is a folder.
487 folderCursor.moveToFirst();
488 boolean isFolder = (folderCursor.getInt(folderCursor.getColumnIndex(IS_FOLDER)) == 1);
490 // Close the cursor and the database handle.
491 folderCursor.close();
492 bookmarksDatabase.close();
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();
502 // Store the updated values.
503 bookmarkContentValues.put(BOOKMARK_NAME, bookmarkName);
504 bookmarkContentValues.put(BOOKMARK_URL, bookmarkUrl);
506 // Get a writable database handle.
507 SQLiteDatabase bookmarksDatabase = this.getWritableDatabase();
509 // Update the bookmark. The last argument is `null` because there are no `whereArgs`.
510 bookmarksDatabase.update(BOOKMARKS_TABLE, bookmarkContentValues, _ID + " = " + databaseId, null);
512 // Close the database handle.
513 bookmarksDatabase.close();
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();
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);
527 // Get a writable database handle.
528 SQLiteDatabase bookmarksDatabase = this.getWritableDatabase();
530 // Update the bookmark. The last argument is `null` because there are no `whereArgs`.
531 bookmarksDatabase.update(BOOKMARKS_TABLE, bookmarkContentValues, _ID + " = " + databaseId, null);
533 // Close the database handle.
534 bookmarksDatabase.close();
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();
542 // Store the updated values.
543 bookmarkContentValues.put(BOOKMARK_NAME, bookmarkName);
544 bookmarkContentValues.put(BOOKMARK_URL, bookmarkUrl);
545 bookmarkContentValues.put(FAVORITE_ICON, favoriteIcon);
547 // Get a writable database handle.
548 SQLiteDatabase bookmarksDatabase = this.getWritableDatabase();
550 // Update the bookmark. The last argument is `null` because there are no `whereArgs`.
551 bookmarksDatabase.update(BOOKMARKS_TABLE, bookmarkContentValues, _ID + " = " + databaseId, null);
553 // Close the database handle.
554 bookmarksDatabase.close();
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();
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);
569 // Get a writable database handle.
570 SQLiteDatabase bookmarksDatabase = this.getWritableDatabase();
572 // Update the bookmark. The last argument is `null` because there are no `whereArgs`.
573 bookmarksDatabase.update(BOOKMARKS_TABLE, bookmarkContentValues, _ID + " = " + databaseId, null);
575 // Close the database handle.
576 bookmarksDatabase.close();
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();
584 // Update the folder first. Store the new folder name in `folderContentValues`.
585 ContentValues folderContentValues = new ContentValues();
586 folderContentValues.put(BOOKMARK_NAME, newFolderName);
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);
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);
595 // SQL escape `oldFolderName`.
596 oldFolderName = DatabaseUtils.sqlEscapeString(oldFolderName);
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);
601 // Close the database handle.
602 bookmarksDatabase.close();
605 // Update the folder icon.
606 public void updateFolder(int databaseId, byte[] folderIcon) {
607 // Get a writable database handle.
608 SQLiteDatabase bookmarksDatabase = this.getWritableDatabase();
610 // Store the updated icon in `folderContentValues`.
611 ContentValues folderContentValues = new ContentValues();
612 folderContentValues.put(FAVORITE_ICON, folderIcon);
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);
617 // Close the database handle.
618 bookmarksDatabase.close();
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();
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);
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);
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);
639 // SQL escape `oldFolderName`.
640 oldFolderName = DatabaseUtils.sqlEscapeString(oldFolderName);
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);
645 // Close the database handle.
646 bookmarksDatabase.close();
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();
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);
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);
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);
666 // SQL escape `oldFolderName`.
667 oldFolderName = DatabaseUtils.sqlEscapeString(oldFolderName);
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);
672 // Close the database handle.
673 bookmarksDatabase.close();
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();
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);
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);
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);
695 // SQL escape `oldFolderName`.
696 oldFolderName = DatabaseUtils.sqlEscapeString(oldFolderName);
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);
701 // Close the database handle.
702 bookmarksDatabase.close();
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();
710 // Store the new display order in `bookmarkContentValues`.
711 ContentValues bookmarkContentValues = new ContentValues();
712 bookmarkContentValues.put(DISPLAY_ORDER, displayOrder);
714 // Update the database. The last argument is `null` because there are no `whereArgs`.
715 bookmarksDatabase.update(BOOKMARKS_TABLE, bookmarkContentValues, _ID + " = " + databaseId, null);
717 // Close the database handle.
718 bookmarksDatabase.close();
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();
726 // SQL escape the new folder name.
727 String newFolderSqlEscaped = DatabaseUtils.sqlEscapeString(newFolder);
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";
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);
737 // Instantiate a variable to store the display order after the move.
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();
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`.
752 // Close the new folder `Cursor`.
753 newFolderCursor.close();
755 // Store the new values in `bookmarkContentValues`.
756 ContentValues bookmarkContentValues = new ContentValues();
757 bookmarkContentValues.put(DISPLAY_ORDER, displayOrder);
758 bookmarkContentValues.put(PARENT_FOLDER, newFolder);
760 // Update the database. The last argument is `null` because there are no `whereArgs`.
761 bookmarksDatabase.update(BOOKMARKS_TABLE, bookmarkContentValues, _ID + " = " + databaseId, null);
763 // Close the database handle.
764 bookmarksDatabase.close();
767 // Delete one bookmark.
768 public void deleteBookmark(int databaseId) {
769 // Get a writable database handle.
770 SQLiteDatabase bookmarksDatabase = this.getWritableDatabase();
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);
775 // Close the database handle.
776 bookmarksDatabase.close();