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