app/src/main/java/com/stoutner/privacybrowser/activities/BookmarksActivity.java

   1 /*
   2  * Copyright © 2016-2022 Soren Stoutner <soren@stoutner.com>.
   3  *
   4  * This file is part of Privacy Browser Android <https://www.stoutner.com/privacy-browser-android>.
   5  *
   6  * Privacy Browser Android 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 Android 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 Android.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 package com.stoutner.privacybrowser.activities;
  21
  22 import android.annotation.SuppressLint;
  23 import android.app.Dialog;
  24 import android.content.Context;
  25 import android.content.Intent;
  26 import android.content.SharedPreferences;
  27 import android.database.Cursor;
  28 import android.graphics.Bitmap;
  29 import android.graphics.BitmapFactory;
  30 import android.graphics.Typeface;
  31 import android.graphics.drawable.BitmapDrawable;
  32 import android.graphics.drawable.Drawable;
  33 import android.os.Bundle;
  34 import android.preference.PreferenceManager;
  35 import android.util.SparseBooleanArray;
  36 import android.view.ActionMode;
  37 import android.view.Menu;
  38 import android.view.MenuItem;
  39 import android.view.View;
  40 import android.view.ViewGroup;
  41 import android.view.Window;
  42 import android.view.WindowManager;
  43 import android.widget.AbsListView;
  44 import android.widget.CursorAdapter;
  45 import android.widget.EditText;
  46 import android.widget.ImageView;
  47 import android.widget.ListView;
  48 import android.widget.RadioButton;
  49 import android.widget.TextView;
  50
  51 import androidx.annotation.NonNull;
  52 import androidx.appcompat.app.ActionBar;
  53 import androidx.appcompat.app.AppCompatActivity;
  54 import androidx.appcompat.widget.Toolbar;
  55 import androidx.fragment.app.DialogFragment;
  56
  57 import com.google.android.material.floatingactionbutton.FloatingActionButton;
  58 import com.google.android.material.snackbar.Snackbar;
  59
  60 import com.stoutner.privacybrowser.dialogs.CreateBookmarkDialog;
  61 import com.stoutner.privacybrowser.dialogs.CreateBookmarkFolderDialog;
  62 import com.stoutner.privacybrowser.dialogs.EditBookmarkDialog;
  63 import com.stoutner.privacybrowser.dialogs.EditBookmarkFolderDialog;
  64 import com.stoutner.privacybrowser.dialogs.MoveToFolderDialog;
  65 import com.stoutner.privacybrowser.R;
  66 import com.stoutner.privacybrowser.helpers.BookmarksDatabaseHelper;
  67
  68 import java.io.ByteArrayOutputStream;
  69 import java.util.ArrayList;
  70
  71 public class BookmarksActivity extends AppCompatActivity implements CreateBookmarkDialog.CreateBookmarkListener, CreateBookmarkFolderDialog.CreateBookmarkFolderListener, EditBookmarkDialog.EditBookmarkListener,
  72         EditBookmarkFolderDialog.EditBookmarkFolderListener, MoveToFolderDialog.MoveToFolderListener {
  73
  74     // `currentFolder` is public static so it can be accessed from `BookmarksDatabaseViewActivity`.
  75     public static String currentFolder;
  76
  77     // `restartFromBookmarksDatabaseViewActivity` is public static so it can be accessed from `BookmarksDatabaseViewActivity`.  It is also used in `onRestart()`.
  78     public static boolean restartFromBookmarksDatabaseViewActivity;
  79
  80
  81     // Define the saved instance state constants.
  82     private final String CHECKED_BOOKMARKS_ARRAY_LIST = "checked_bookmarks_array_list";
  83
  84     // Define the class menu items.
  85     private MenuItem moveBookmarkUpMenuItem;
  86     private MenuItem moveBookmarkDownMenuItem;
  87
  88     // `bookmarksDatabaseHelper` is used in `onCreate()`, `onOptionsItemSelected()`, `onBackPressed()`, `onCreateBookmark()`, `onCreateBookmarkFolder()`, `onSaveBookmark()`, `onSaveBookmarkFolder()`,
  89     // `onMoveToFolder()`, `deleteBookmarkFolderContents()`, `loadFolder()`, and `onDestroy()`.
  90     private BookmarksDatabaseHelper bookmarksDatabaseHelper;
  91
  92     // `bookmarksListView` is used in `onCreate()`, `onOptionsItemSelected()`, `onCreateBookmark()`, `onCreateBookmarkFolder()`, `onSaveBookmark()`, `onSaveBookmarkFolder()`, `onMoveToFolder()`,
  93     // `updateMoveIcons()`, `scrollBookmarks()`, and `loadFolder()`.
  94     private ListView bookmarksListView;
  95
  96     // `bookmarksCursor` is used in `onCreate()`, `onCreateBookmark()`, `onCreateBookmarkFolder()`, `onSaveBookmark()`, `onSaveBookmarkFolder()`, `onMoveToFolder()`, `deleteBookmarkFolderContents()`,
  97     // `loadFolder()`, and `onDestroy()`.
  98     private Cursor bookmarksCursor;
  99
 100     // `bookmarksCursorAdapter` is used in `onCreate(), `onCreateBookmark()`, `onCreateBookmarkFolder()`, `onSaveBookmark()`, `onSaveBookmarkFolder()`, `onMoveToFolder()`, and `onLoadFolder()`.
 101     private CursorAdapter bookmarksCursorAdapter;
 102
 103     // `contextualActionMode` is used in `onCreate()`, `onSaveEditBookmark()`, `onSaveEditBookmarkFolder()` and `onMoveToFolder()`.
 104     private ActionMode contextualActionMode;
 105
 106     // `appBar` is used in `onCreate()` and `loadFolder()`.
 107     private ActionBar appBar;
 108
 109     // `oldFolderName` is used in `onCreate()` and `onSaveBookmarkFolder()`.
 110     private String oldFolderNameString;
 111
 112     // `bookmarksDeletedSnackbar` is used in `onCreate()`, `onOptionsItemSelected()`, and `onBackPressed()`.
 113     private Snackbar bookmarksDeletedSnackbar;
 114
 115     // `closeActivityAfterDismissingSnackbar` is used in `onCreate()`, `onOptionsItemSelected()`, and `onBackPressed()`.
 116     private boolean closeActivityAfterDismissingSnackbar;
 117
 118     // The favorite icon byte array is populated in `onCreate()` and used in `onOptionsItemSelected()`.
 119     private byte[] favoriteIconByteArray;
 120
 121     @Override
 122     protected void onCreate(Bundle savedInstanceState) {
 123         // Get a handle for the shared preferences.
 124         SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(this);
 125
 126         // Get the preferences.
 127         boolean allowScreenshots = sharedPreferences.getBoolean(getString(R.string.allow_screenshots_key), false);
 128         boolean bottomAppBar = sharedPreferences.getBoolean(getString(R.string.bottom_app_bar_key), false);
 129
 130         // Disable screenshots if not allowed.
 131         if (!allowScreenshots) {
 132             getWindow().addFlags(WindowManager.LayoutParams.FLAG_SECURE);
 133         }
 134
 135         // Run the default commands.
 136         super.onCreate(savedInstanceState);
 137
 138         // Get the intent that launched the activity.
 139         Intent launchingIntent = getIntent();
 140
 141         // Store the current URL and title.
 142         String currentUrl = launchingIntent.getStringExtra("current_url");
 143         String currentTitle = launchingIntent.getStringExtra("current_title");
 144
 145         // Set the current folder variable.
 146         if (launchingIntent.getStringExtra("current_folder") != null) {  // Set the current folder from the intent.
 147             currentFolder = launchingIntent.getStringExtra("current_folder");
 148         } else {  // Set the current folder to be `""`, which is the home folder.
 149             currentFolder = "";
 150         }
 151
 152         // Get the favorite icon byte array.
 153         favoriteIconByteArray = launchingIntent.getByteArrayExtra("favorite_icon_byte_array");
 154
 155         // Remove the incorrect lint warning that the favorite icon byte array might be null.
 156         assert favoriteIconByteArray != null;
 157
 158         // Convert the favorite icon byte array to a bitmap.
 159         Bitmap favoriteIconBitmap = BitmapFactory.decodeByteArray(favoriteIconByteArray, 0, favoriteIconByteArray.length);
 160
 161         // Set the content according to the app bar position.
 162         if (bottomAppBar) {
 163             // Set the content view.
 164             setContentView(R.layout.bookmarks_bottom_appbar);
 165         } else {
 166             // `Window.FEATURE_ACTION_MODE_OVERLAY` makes the contextual action mode cover the support action bar.  It must be requested before the content is set.
 167             supportRequestWindowFeature(Window.FEATURE_ACTION_MODE_OVERLAY);
 168
 169             // Set the content view.
 170             setContentView(R.layout.bookmarks_top_appbar);
 171         }
 172
 173         // Get a handle for the toolbar.
 174         final Toolbar toolbar = findViewById(R.id.bookmarks_toolbar);
 175
 176         // Set the support action bar.
 177         setSupportActionBar(toolbar);
 178
 179         // Get handles for the views.
 180         appBar = getSupportActionBar();
 181         bookmarksListView = findViewById(R.id.bookmarks_listview);
 182
 183         // Remove the incorrect lint warning that `appBar` might be null.
 184         assert appBar != null;
 185
 186         // Display the home arrow on the app bar.
 187         appBar.setDisplayHomeAsUpEnabled(true);
 188
 189         // Initialize the database helper.
 190         bookmarksDatabaseHelper = new BookmarksDatabaseHelper(this);
 191
 192         // Load the home folder.
 193         loadFolder();
 194
 195         // Set a listener so that tapping a list item loads the URL or folder.
 196         bookmarksListView.setOnItemClickListener((parent, view, position, id) -> {
 197             // Convert the id from long to int to match the format of the bookmarks database.
 198             int databaseId = (int) id;
 199
 200             // Get the bookmark cursor for this ID.
 201             Cursor bookmarkCursor = bookmarksDatabaseHelper.getBookmark(databaseId);
 202
 203             // Move the cursor to the first entry.
 204             bookmarkCursor.moveToFirst();
 205
 206             // Act upon the bookmark according to the type.
 207             if (bookmarkCursor.getInt(bookmarkCursor.getColumnIndexOrThrow(BookmarksDatabaseHelper.IS_FOLDER)) == 1) {  // The selected bookmark is a folder.
 208                 // Update the current folder.
 209                 currentFolder = bookmarkCursor.getString(bookmarkCursor.getColumnIndexOrThrow(BookmarksDatabaseHelper.BOOKMARK_NAME));
 210
 211                 // Load the new folder.
 212                 loadFolder();
 213             } else {  // The selected bookmark is not a folder.
 214                 // Instantiate the edit bookmark dialog.
 215                 DialogFragment editBookmarkDialog = EditBookmarkDialog.bookmarkDatabaseId(databaseId, favoriteIconBitmap);
 216
 217                 // Make it so.
 218                 editBookmarkDialog.show(getSupportFragmentManager(), getResources().getString(R.string.edit_bookmark));
 219             }
 220
 221             // Close the cursor.
 222             bookmarkCursor.close();
 223         });
 224
 225         // Handle long presses on the list view.
 226         bookmarksListView.setMultiChoiceModeListener(new AbsListView.MultiChoiceModeListener() {
 227             // Instantiate the common variables.
 228             MenuItem editBookmarkMenuItem;
 229             MenuItem deleteBookmarksMenuItem;
 230             MenuItem selectAllBookmarksMenuItem;
 231             boolean deletingBookmarks;
 232
 233             @Override
 234             public boolean onCreateActionMode(ActionMode mode, Menu menu) {
 235                 // Inflate the menu for the contextual app bar.
 236                 getMenuInflater().inflate(R.menu.bookmarks_context_menu, menu);
 237
 238                 // Set the title.
 239                 if (currentFolder.isEmpty()) {  // Use `R.string.bookmarks` if in the home folder.
 240                     mode.setTitle(R.string.bookmarks);
 241                 } else {  // Use the current folder name as the title.
 242                     mode.setTitle(currentFolder);
 243                 }
 244
 245                 // Get handles for menu items that need to be selectively disabled.
 246                 moveBookmarkUpMenuItem = menu.findItem(R.id.move_bookmark_up);
 247                 moveBookmarkDownMenuItem = menu.findItem(R.id.move_bookmark_down);
 248                 editBookmarkMenuItem = menu.findItem(R.id.edit_bookmark);
 249                 deleteBookmarksMenuItem = menu.findItem(R.id.delete_bookmark);
 250                 selectAllBookmarksMenuItem = menu.findItem(R.id.context_menu_select_all_bookmarks);
 251
 252                 // Disable the delete bookmarks menu item if a delete is pending.
 253                 deleteBookmarksMenuItem.setEnabled(!deletingBookmarks);
 254
 255                 // Store a handle for the contextual action mode so it can be closed programatically.
 256                 contextualActionMode = mode;
 257
 258                 // Make it so.
 259                 return true;
 260             }
 261
 262             @Override
 263             public boolean onPrepareActionMode(ActionMode mode, Menu menu) {
 264                 // Get a handle for the move to folder menu item.
 265                 MenuItem moveToFolderMenuItem = menu.findItem(R.id.move_to_folder);
 266
 267                 // Get a Cursor with all of the folders.
 268                 Cursor folderCursor = bookmarksDatabaseHelper.getAllFolders();
 269
 270                 // Enable the move to folder menu item if at least one folder exists.
 271                 moveToFolderMenuItem.setVisible(folderCursor.getCount() > 0);
 272
 273                 // Make it so.
 274                 return true;
 275             }
 276
 277             @Override
 278             public void onItemCheckedStateChanged(ActionMode mode, int position, long id, boolean checked) {
 279                 // Get the number of selected bookmarks.
 280                 int numberOfSelectedBookmarks = bookmarksListView.getCheckedItemCount();
 281
 282                 // Only process commands if at least one bookmark is selected.  Otherwise, a context menu with 0 selected bookmarks is briefly displayed.
 283                 if (numberOfSelectedBookmarks > 0) {
 284                     // Adjust the ActionMode and the menu according to the number of selected bookmarks.
 285                     if (numberOfSelectedBookmarks == 1) {  // One bookmark is selected.
 286                         // List the number of selected bookmarks in the subtitle.
 287                         mode.setSubtitle(getString(R.string.selected) + "  1");
 288
 289                         // Show the `Move Up`, `Move Down`, and  `Edit` options.
 290                         moveBookmarkUpMenuItem.setVisible(true);
 291                         moveBookmarkDownMenuItem.setVisible(true);
 292                         editBookmarkMenuItem.setVisible(true);
 293
 294                         // Update the enabled status of the move icons.
 295                         updateMoveIcons();
 296                     } else {  // More than one bookmark is selected.
 297                         // List the number of selected bookmarks in the subtitle.
 298                         mode.setSubtitle(getString(R.string.selected) + "  " + numberOfSelectedBookmarks);
 299
 300                         // Hide non-applicable `MenuItems`.
 301                         moveBookmarkUpMenuItem.setVisible(false);
 302                         moveBookmarkDownMenuItem.setVisible(false);
 303                         editBookmarkMenuItem.setVisible(false);
 304                     }
 305
 306                     // Show the select all menu item if all the bookmarks are not selected.
 307                     selectAllBookmarksMenuItem.setVisible(bookmarksListView.getCheckedItemCount() != bookmarksListView.getCount());
 308                 }
 309             }
 310
 311             @Override
 312             public boolean onActionItemClicked(ActionMode actionMode, MenuItem menuItem) {
 313                 // Declare the common variables.
 314                 int selectedBookmarkNewPosition;
 315                 final SparseBooleanArray selectedBookmarksPositionsSparseBooleanArray;
 316
 317                 // Initialize the selected bookmark position.
 318                 int selectedBookmarkPosition = 0;
 319
 320                 // Get the menu item ID.
 321                 int menuItemId = menuItem.getItemId();
 322
 323                 // Run the commands according to the selected action item.
 324                 if (menuItemId == R.id.move_bookmark_up) {  // Move the bookmark up.
 325                     // Get the array of checked bookmark positions.
 326                     selectedBookmarksPositionsSparseBooleanArray = bookmarksListView.getCheckedItemPositions();
 327
 328                     // Get the position of the bookmark that is selected.  If other bookmarks have previously been selected they will be included in the sparse boolean array with a value of `false`.
 329                     for (int i = 0; i < selectedBookmarksPositionsSparseBooleanArray.size(); i++) {
 330                         // Check to see if the value for the bookmark is true, meaning it is currently selected.
 331                         if (selectedBookmarksPositionsSparseBooleanArray.valueAt(i)) {
 332                             // Only one bookmark should have a value of `true` when move bookmark up is enabled.
 333                             selectedBookmarkPosition = selectedBookmarksPositionsSparseBooleanArray.keyAt(i);
 334                         }
 335                     }
 336
 337                     // Calculate the new position of the selected bookmark.
 338                     selectedBookmarkNewPosition = selectedBookmarkPosition - 1;
 339
 340                     // Iterate through the bookmarks.
 341                     for (int i = 0; i < bookmarksListView.getCount(); i++) {
 342                         // Get the database ID for the current bookmark.
 343                         int currentBookmarkDatabaseId = (int) bookmarksListView.getItemIdAtPosition(i);
 344
 345                         // Update the display order for the current bookmark.
 346                         if (i == selectedBookmarkPosition) {  // The current bookmark is the selected bookmark.
 347                             // Move the current bookmark up one.
 348                             bookmarksDatabaseHelper.updateDisplayOrder(currentBookmarkDatabaseId, i - 1);
 349                         } else if ((i + 1) == selectedBookmarkPosition) {  // The current bookmark is immediately above the selected bookmark.
 350                             // Move the current bookmark down one.
 351                             bookmarksDatabaseHelper.updateDisplayOrder(currentBookmarkDatabaseId, i + 1);
 352                         } else {  // The current bookmark is not changing positions.
 353                             // Move `bookmarksCursor` to the current bookmark position.
 354                             bookmarksCursor.moveToPosition(i);
 355
 356                             // Update the display order only if it is not correct in the database.
 357                             if (bookmarksCursor.getInt(bookmarksCursor.getColumnIndexOrThrow(BookmarksDatabaseHelper.DISPLAY_ORDER)) != i) {
 358                                 bookmarksDatabaseHelper.updateDisplayOrder(currentBookmarkDatabaseId, i);
 359                             }
 360                         }
 361                     }
 362
 363                     // Update the bookmarks cursor with the current contents of the bookmarks database.
 364                     bookmarksCursor = bookmarksDatabaseHelper.getBookmarksByDisplayOrder(currentFolder);
 365
 366                     // Update the list view.
 367                     bookmarksCursorAdapter.changeCursor(bookmarksCursor);
 368
 369                     // Scroll with the bookmark.
 370                     scrollBookmarks(selectedBookmarkNewPosition);
 371
 372                     // Update the enabled status of the move icons.
 373                     updateMoveIcons();
 374                 } else if (menuItemId == R.id.move_bookmark_down) {  // Move the bookmark down.
 375                     // Get the array of checked bookmark positions.
 376                     selectedBookmarksPositionsSparseBooleanArray = bookmarksListView.getCheckedItemPositions();
 377
 378                     // Get the position of the bookmark that is selected.  If other bookmarks have previously been selected they will be included in the sparse boolean array with a value of `false`.
 379                     for (int i = 0; i < selectedBookmarksPositionsSparseBooleanArray.size(); i++) {
 380                         // Check to see if the value for the bookmark is true, meaning it is currently selected.
 381                         if (selectedBookmarksPositionsSparseBooleanArray.valueAt(i)) {
 382                             // Only one bookmark should have a value of `true` when move bookmark down is enabled.
 383                             selectedBookmarkPosition = selectedBookmarksPositionsSparseBooleanArray.keyAt(i);
 384                         }
 385                     }
 386
 387                     // Calculate the new position of the selected bookmark.
 388                     selectedBookmarkNewPosition = selectedBookmarkPosition + 1;
 389
 390                     // Iterate through the bookmarks.
 391                     for (int i = 0; i < bookmarksListView.getCount(); i++) {
 392                         // Get the database ID for the current bookmark.
 393                         int currentBookmarkDatabaseId = (int) bookmarksListView.getItemIdAtPosition(i);
 394
 395                         // Update the display order for the current bookmark.
 396                         if (i == selectedBookmarkPosition) {  // The current bookmark is the selected bookmark.
 397                             // Move the current bookmark down one.
 398                             bookmarksDatabaseHelper.updateDisplayOrder(currentBookmarkDatabaseId, i + 1);
 399                         } else if ((i - 1) == selectedBookmarkPosition) {  // The current bookmark is immediately below the selected bookmark.
 400                             // Move the bookmark below the selected bookmark up one.
 401                             bookmarksDatabaseHelper.updateDisplayOrder(currentBookmarkDatabaseId, i - 1);
 402                         } else {  // The current bookmark is not changing positions.
 403                             // Move `bookmarksCursor` to the current bookmark position.
 404                             bookmarksCursor.moveToPosition(i);
 405
 406                             // Update the display order only if it is not correct in the database.
 407                             if (bookmarksCursor.getInt(bookmarksCursor.getColumnIndexOrThrow(BookmarksDatabaseHelper.DISPLAY_ORDER)) != i) {
 408                                 bookmarksDatabaseHelper.updateDisplayOrder(currentBookmarkDatabaseId, i);
 409                             }
 410                         }
 411                     }
 412
 413                     // Update the bookmarks cursor with the current contents of the bookmarks database.
 414                     bookmarksCursor = bookmarksDatabaseHelper.getBookmarksByDisplayOrder(currentFolder);
 415
 416                     // Update the list view.
 417                     bookmarksCursorAdapter.changeCursor(bookmarksCursor);
 418
 419                     // Scroll with the bookmark.
 420                     scrollBookmarks(selectedBookmarkNewPosition);
 421
 422                     // Update the enabled status of the move icons.
 423                     updateMoveIcons();
 424                 } else if (menuItemId == R.id.move_to_folder) {  // Move to folder.
 425                     // Instantiate the move to folder alert dialog.
 426                     DialogFragment moveToFolderDialog = MoveToFolderDialog.moveBookmarks(currentFolder, bookmarksListView.getCheckedItemIds());
 427
 428                     // Show the move to folder alert dialog.
 429                     moveToFolderDialog.show(getSupportFragmentManager(), getResources().getString(R.string.move_to_folder));
 430                 } else if (menuItemId == R.id.edit_bookmark) {
 431                     // Get the array of checked bookmark positions.
 432                     selectedBookmarksPositionsSparseBooleanArray = bookmarksListView.getCheckedItemPositions();
 433
 434                     // Get the position of the bookmark that is selected.  If other bookmarks have previously been selected they will be included in the sparse boolean array with a value of `false`.
 435                     for (int i = 0; i < selectedBookmarksPositionsSparseBooleanArray.size(); i++) {
 436                         // Check to see if the value for the bookmark is true, meaning it is currently selected.
 437                         if (selectedBookmarksPositionsSparseBooleanArray.valueAt(i)) {
 438                             // Only one bookmark should have a value of `true` when move edit bookmark is enabled.
 439                             selectedBookmarkPosition = selectedBookmarksPositionsSparseBooleanArray.keyAt(i);
 440                         }
 441                     }
 442
 443                     // Move the cursor to the selected position.
 444                     bookmarksCursor.moveToPosition(selectedBookmarkPosition);
 445
 446                     // Find out if this bookmark is a folder.
 447                     boolean isFolder = (bookmarksCursor.getInt(bookmarksCursor.getColumnIndexOrThrow(BookmarksDatabaseHelper.IS_FOLDER)) == 1);
 448
 449                     // Get the selected bookmark database ID.
 450                     int databaseId = bookmarksCursor.getInt(bookmarksCursor.getColumnIndexOrThrow(BookmarksDatabaseHelper.ID));
 451
 452                     // Show the edit bookmark or edit bookmark folder dialog.
 453                     if (isFolder) {
 454                         // Save the current folder name, which is used in `onSaveBookmarkFolder()`.
 455                         oldFolderNameString = bookmarksCursor.getString(bookmarksCursor.getColumnIndexOrThrow(BookmarksDatabaseHelper.BOOKMARK_NAME));
 456
 457                         // Instantiate the edit bookmark folder dialog.
 458                         DialogFragment editFolderDialog = EditBookmarkFolderDialog.folderDatabaseId(databaseId, favoriteIconBitmap);
 459
 460                         // Make it so.
 461                         editFolderDialog.show(getSupportFragmentManager(), getResources().getString(R.string.edit_folder));
 462                     } else {
 463                         // Instantiate the edit bookmark dialog.
 464                         DialogFragment editBookmarkDialog = EditBookmarkDialog.bookmarkDatabaseId(databaseId, favoriteIconBitmap);
 465
 466                         // Make it so.
 467                         editBookmarkDialog.show(getSupportFragmentManager(), getResources().getString(R.string.edit_bookmark));
 468                     }
 469                 } else if (menuItemId == R.id.delete_bookmark) {  // Delete bookmark.
 470                     // Set the deleting bookmarks flag, which prevents the delete menu item from being enabled until the current process finishes.
 471                     deletingBookmarks = true;
 472
 473                     // Get an array of the selected row IDs.
 474                     final long[] selectedBookmarksIdsLongArray = bookmarksListView.getCheckedItemIds();
 475
 476                     // Initialize a variable to count the number of bookmarks to delete.
 477                     int numberOfBookmarksToDelete = 0;
 478
 479                     // Count the number of bookmarks.
 480                     for (long databaseIdLong : selectedBookmarksIdsLongArray) {
 481                         // Convert the database ID long to an int.
 482                         int databaseIdInt = (int) databaseIdLong;
 483
 484                         // Count the contents of the folder if the selected bookmark is a folder.
 485                         if (bookmarksDatabaseHelper.isFolder(databaseIdInt)) {
 486                             // Add the bookmarks from the folder to the running total.
 487                             numberOfBookmarksToDelete = numberOfBookmarksToDelete + countBookmarkFolderContents(databaseIdInt);
 488                         }
 489
 490                         // Increment the count of the number of bookmarks to delete.
 491                         numberOfBookmarksToDelete++;
 492                     }
 493
 494                     // Get an array of checked bookmarks.  `.clone()` makes a copy that won't change if the list view is reloaded, which is needed for re-selecting the bookmarks on undelete.
 495                     selectedBookmarksPositionsSparseBooleanArray = bookmarksListView.getCheckedItemPositions().clone();
 496
 497                     // Update the bookmarks cursor with the current contents of the bookmarks database except for the specified database IDs.
 498                     bookmarksCursor = bookmarksDatabaseHelper.getBookmarksByDisplayOrderExcept(selectedBookmarksIdsLongArray, currentFolder);
 499
 500                     // Update the list view.
 501                     bookmarksCursorAdapter.changeCursor(bookmarksCursor);
 502
 503                     // Create a Snackbar with the number of deleted bookmarks.
 504                     bookmarksDeletedSnackbar = Snackbar.make(findViewById(R.id.bookmarks_coordinatorlayout), getString(R.string.bookmarks_deleted) + "  " + numberOfBookmarksToDelete,
 505                             Snackbar.LENGTH_LONG)
 506                             .setAction(R.string.undo, view -> {
 507                                 // Do nothing because everything will be handled by `onDismissed()` below.
 508                             })
 509                             .addCallback(new Snackbar.Callback() {
 510                                 @SuppressLint("SwitchIntDef")  // Ignore the lint warning about not handling the other possible events as they are covered by `default:`.
 511                                 @Override
 512                                 public void onDismissed(Snackbar snackbar, int event) {
 513                                     if (event == Snackbar.Callback.DISMISS_EVENT_ACTION) {  // The user pushed the undo button.
 514                                         // Update the bookmarks cursor with the current contents of the bookmarks database, including the "deleted" bookmarks.
 515                                         bookmarksCursor = bookmarksDatabaseHelper.getBookmarksByDisplayOrder(currentFolder);
 516
 517                                         // Update the list view.
 518                                         bookmarksCursorAdapter.changeCursor(bookmarksCursor);
 519
 520                                         // Re-select the previously selected bookmarks.
 521                                         for (int i = 0; i < selectedBookmarksPositionsSparseBooleanArray.size(); i++) {
 522                                             bookmarksListView.setItemChecked(selectedBookmarksPositionsSparseBooleanArray.keyAt(i), true);
 523                                         }
 524                                     } else {  // The snackbar was dismissed without the undo button being pushed.
 525                                         // Delete each selected bookmark.
 526                                         for (long databaseIdLong : selectedBookmarksIdsLongArray) {
 527                                             // Convert `databaseIdLong` to an int.
 528                                             int databaseIdInt = (int) databaseIdLong;
 529
 530                                             // Delete the contents of the folder if the selected bookmark is a folder.
 531                                             if (bookmarksDatabaseHelper.isFolder(databaseIdInt)) {
 532                                                 deleteBookmarkFolderContents(databaseIdInt);
 533                                             }
 534
 535                                             // Delete the selected bookmark.
 536                                             bookmarksDatabaseHelper.deleteBookmark(databaseIdInt);
 537                                         }
 538
 539                                         // Update the display order.
 540                                         for (int i = 0; i < bookmarksListView.getCount(); i++) {
 541                                             // Get the database ID for the current bookmark.
 542                                             int currentBookmarkDatabaseId = (int) bookmarksListView.getItemIdAtPosition(i);
 543
 544                                             // Move `bookmarksCursor` to the current bookmark position.
 545                                             bookmarksCursor.moveToPosition(i);
 546
 547                                             // Update the display order only if it is not correct in the database.
 548                                             if (bookmarksCursor.getInt(bookmarksCursor.getColumnIndexOrThrow(BookmarksDatabaseHelper.DISPLAY_ORDER)) != i) {
 549                                                 bookmarksDatabaseHelper.updateDisplayOrder(currentBookmarkDatabaseId, i);
 550                                             }
 551                                         }
 552                                     }
 553
 554                                     // Reset the deleting bookmarks flag.
 555                                     deletingBookmarks = false;
 556
 557                                     // Enable the delete bookmarks menu item.
 558                                     deleteBookmarksMenuItem.setEnabled(true);
 559
 560                                     // Close the activity if back has been pressed.
 561                                     if (closeActivityAfterDismissingSnackbar) {
 562                                         onBackPressed();
 563                                     }
 564                                 }
 565                             });
 566
 567                     //Show the Snackbar.
 568                     bookmarksDeletedSnackbar.show();
 569                 } else if (menuItemId == R.id.context_menu_select_all_bookmarks) {  // Select all.
 570                     // Get the total number of bookmarks.
 571                     int numberOfBookmarks = bookmarksListView.getCount();
 572
 573                     // Select them all.
 574                     for (int i = 0; i < numberOfBookmarks; i++) {
 575                         bookmarksListView.setItemChecked(i, true);
 576                     }
 577                 }
 578
 579                 // Consume the click.
 580                 return true;
 581             }
 582
 583             @Override
 584             public void onDestroyActionMode(ActionMode mode) {
 585                 // Do nothing.
 586             }
 587         });
 588
 589         // Get handles for the floating action buttons.
 590         FloatingActionButton createBookmarkFolderFab = findViewById(R.id.create_bookmark_folder_fab);
 591         FloatingActionButton createBookmarkFab = findViewById(R.id.create_bookmark_fab);
 592
 593         // Set the create new bookmark folder FAB to display the `AlertDialog`.
 594         createBookmarkFolderFab.setOnClickListener(v -> {
 595             // Create a create bookmark folder dialog.
 596             DialogFragment createBookmarkFolderDialog = CreateBookmarkFolderDialog.createBookmarkFolder(favoriteIconBitmap);
 597
 598             // Show the create bookmark folder dialog.
 599             createBookmarkFolderDialog.show(getSupportFragmentManager(), getString(R.string.create_folder));
 600         });
 601
 602         // Set the create new bookmark FAB to display the alert dialog.
 603         createBookmarkFab.setOnClickListener(view -> {
 604             // Remove the incorrect lint warning below.
 605             assert currentUrl != null;
 606             assert currentTitle != null;
 607
 608             // Instantiate the create bookmark dialog.
 609             DialogFragment createBookmarkDialog = CreateBookmarkDialog.createBookmark(currentUrl, currentTitle, favoriteIconBitmap);
 610
 611             // Display the create bookmark dialog.
 612             createBookmarkDialog.show(getSupportFragmentManager(), getResources().getString(R.string.create_bookmark));
 613         });
 614
 615         // Restore the state if the app has been restarted.
 616         if (savedInstanceState != null) {
 617             // Update the bookmarks list view after it has loaded.
 618             bookmarksListView.post(() -> {
 619                 // Get the checked bookmarks array list.
 620                 ArrayList<Integer> checkedBookmarksArrayList = savedInstanceState.getIntegerArrayList(CHECKED_BOOKMARKS_ARRAY_LIST);
 621
 622                 // Check each previously checked bookmark in the list view.  When the minimum API >= 24 a `forEach()` command can be used instead.
 623                 if (checkedBookmarksArrayList != null) {
 624                     for (int i = 0; i < checkedBookmarksArrayList.size(); i++) {
 625                         bookmarksListView.setItemChecked(checkedBookmarksArrayList.get(i), true);
 626                     }
 627                 }
 628             });
 629         }
 630     }
 631
 632     @Override
 633     public void onRestart() {
 634         // Run the default commands.
 635         super.onRestart();
 636
 637         // Update the list view if returning from the bookmarks database view activity.
 638         if (restartFromBookmarksDatabaseViewActivity) {
 639             // Load the current folder in the list view.
 640             loadFolder();
 641
 642             // Reset `restartFromBookmarksDatabaseViewActivity`.
 643             restartFromBookmarksDatabaseViewActivity = false;
 644         }
 645     }
 646
 647     @Override
 648     public void onSaveInstanceState(@NonNull Bundle savedInstanceState) {
 649         // Run the default commands.
 650         super.onSaveInstanceState(savedInstanceState);
 651
 652         // Get the array of the checked items.
 653         SparseBooleanArray checkedBookmarksSparseBooleanArray = bookmarksListView.getCheckedItemPositions();
 654
 655         // Create a checked items array list.
 656         ArrayList<Integer> checkedBookmarksArrayList = new ArrayList<>();
 657
 658         // Add each checked bookmark position to the array list.
 659         for (int i = 0; i < checkedBookmarksSparseBooleanArray.size(); i++) {
 660             // Check to see if the bookmark is currently checked.  Bookmarks that have previously been checked but currently aren't will be populated in the sparse boolean array, but will return false.
 661             if (checkedBookmarksSparseBooleanArray.valueAt(i)) {
 662                 // Add the bookmark position to the checked bookmarks array list.
 663                 checkedBookmarksArrayList.add(checkedBookmarksSparseBooleanArray.keyAt(i));
 664             }
 665         }
 666
 667         // Store the checked items array list in the saved instance state.
 668         savedInstanceState.putIntegerArrayList(CHECKED_BOOKMARKS_ARRAY_LIST, checkedBookmarksArrayList);
 669     }
 670
 671     @Override
 672     public boolean onCreateOptionsMenu(Menu menu) {
 673         // Inflate the menu.
 674         getMenuInflater().inflate(R.menu.bookmarks_options_menu, menu);
 675
 676         // Success.
 677         return true;
 678     }
 679
 680     @Override
 681     public boolean onOptionsItemSelected(MenuItem menuItem) {
 682         // Get a handle for the menu item ID.
 683         int menuItemId = menuItem.getItemId();
 684
 685         // Run the command according to the selected option.
 686         if (menuItemId == android.R.id.home) {  // Home.  The home arrow is identified as `android.R.id.home`, not just `R.id.home`.
 687             if (currentFolder.isEmpty()) {  // Currently in the home folder.
 688                 // Run the back commands.
 689                 onBackPressed();
 690             } else {  // Currently in a subfolder.
 691                 // Place the former parent folder in `currentFolder`.
 692                 currentFolder = bookmarksDatabaseHelper.getParentFolderName(currentFolder);
 693
 694                 // Load the new folder.
 695                 loadFolder();
 696             }
 697         } else if (menuItemId == R.id.options_menu_select_all_bookmarks) {  // Select all.
 698             // Get the total number of bookmarks.
 699             int numberOfBookmarks = bookmarksListView.getCount();
 700
 701             // Select them all.
 702             for (int i = 0; i < numberOfBookmarks; i++) {
 703                 bookmarksListView.setItemChecked(i, true);
 704             }
 705         } else if (menuItemId == R.id.bookmarks_database_view) {
 706             // Close the contextual action bar if it is displayed.  This can happen if the bottom app bar is enabled.
 707             if (contextualActionMode != null) {
 708                 contextualActionMode.finish();
 709             }
 710
 711             // Create an intent to launch the bookmarks database view activity.
 712             Intent bookmarksDatabaseViewIntent = new Intent(this, BookmarksDatabaseViewActivity.class);
 713
 714             // Include the favorite icon byte array to the intent.
 715             bookmarksDatabaseViewIntent.putExtra("favorite_icon_byte_array", favoriteIconByteArray);
 716
 717             // Make it so.
 718             startActivity(bookmarksDatabaseViewIntent);
 719         }
 720         return true;
 721     }
 722
 723     @Override
 724     public void onBackPressed() {
 725         // Check to see if a snackbar is currently displayed.  If so, it must be closed before exiting so that a pending delete is completed before reloading the list view in the bookmarks drawer.
 726         if ((bookmarksDeletedSnackbar != null) && bookmarksDeletedSnackbar.isShown()) {  // Close the bookmarks deleted snackbar before going home.
 727             // Set the close flag.
 728             closeActivityAfterDismissingSnackbar = true;
 729
 730             // Dismiss the snackbar.
 731             bookmarksDeletedSnackbar.dismiss();
 732         } else {  // Go home immediately.
 733             // Update the bookmarks folder for the bookmarks drawer in the main WebView activity.
 734             MainWebViewActivity.currentBookmarksFolder = currentFolder;
 735
 736             // Close the bookmarks drawer and reload the bookmarks ListView when returning to the main WebView activity.
 737             MainWebViewActivity.restartFromBookmarksActivity = true;
 738
 739             // Exit the bookmarks activity.
 740             super.onBackPressed();
 741         }
 742     }
 743
 744     @Override
 745     public void onCreateBookmark(DialogFragment dialogFragment, Bitmap favoriteIconBitmap) {
 746         // Get the alert dialog from the fragment.
 747         Dialog dialog = dialogFragment.getDialog();
 748
 749         // Remove the incorrect lint warning below that the dialog might be null.
 750         assert dialog != null;
 751
 752         // Get the views from the dialog fragment.
 753         EditText createBookmarkNameEditText = dialog.findViewById(R.id.create_bookmark_name_edittext);
 754         EditText createBookmarkUrlEditText = dialog.findViewById(R.id.create_bookmark_url_edittext);
 755
 756         // Extract the strings from the edit texts.
 757         String bookmarkNameString = createBookmarkNameEditText.getText().toString();
 758         String bookmarkUrlString = createBookmarkUrlEditText.getText().toString();
 759
 760         // Create a favorite icon byte array output stream.
 761         ByteArrayOutputStream favoriteIconByteArrayOutputStream = new ByteArrayOutputStream();
 762
 763         // Convert the favorite icon bitmap to a byte array.  `0` is for lossless compression (the only option for a PNG).
 764         favoriteIconBitmap.compress(Bitmap.CompressFormat.PNG, 0, favoriteIconByteArrayOutputStream);
 765
 766         // Convert the favorite icon byte array stream to a byte array.
 767         byte[] favoriteIconByteArray = favoriteIconByteArrayOutputStream.toByteArray();
 768
 769         // Display the new bookmark below the current items in the (0 indexed) list.
 770         int newBookmarkDisplayOrder = bookmarksListView.getCount();
 771
 772         // Create the bookmark.
 773         bookmarksDatabaseHelper.createBookmark(bookmarkNameString, bookmarkUrlString, currentFolder, newBookmarkDisplayOrder, favoriteIconByteArray);
 774
 775         // Update the bookmarks cursor with the current contents of this folder.
 776         bookmarksCursor = bookmarksDatabaseHelper.getBookmarksByDisplayOrder(currentFolder);
 777
 778         // Update the `ListView`.
 779         bookmarksCursorAdapter.changeCursor(bookmarksCursor);
 780
 781         // Scroll to the new bookmark.
 782         bookmarksListView.setSelection(newBookmarkDisplayOrder);
 783     }
 784
 785     @Override
 786     public void onCreateBookmarkFolder(DialogFragment dialogFragment, @NonNull Bitmap favoriteIconBitmap) {
 787         // Get the dialog from the dialog fragment.
 788         Dialog dialog = dialogFragment.getDialog();
 789
 790         // Remove the incorrect lint warning below that the dialog might be null.
 791         assert dialog != null;
 792
 793         // Get handles for the views in the dialog fragment.
 794         EditText folderNameEditText = dialog.findViewById(R.id.folder_name_edittext);
 795         RadioButton defaultIconRadioButton = dialog.findViewById(R.id.default_icon_radiobutton);
 796         ImageView defaultIconImageView = dialog.findViewById(R.id.default_icon_imageview);
 797
 798         // Get new folder name string.
 799         String folderNameString = folderNameEditText.getText().toString();
 800
 801         // Create a folder icon bitmap.
 802         Bitmap folderIconBitmap;
 803
 804         // Set the folder icon bitmap according to the dialog.
 805         if (defaultIconRadioButton.isChecked()) {  // Use the default folder icon.
 806             // Get the default folder icon drawable.
 807             Drawable folderIconDrawable = defaultIconImageView.getDrawable();
 808
 809             // Convert the folder icon drawable to a bitmap drawable.
 810             BitmapDrawable folderIconBitmapDrawable = (BitmapDrawable) folderIconDrawable;
 811
 812             // Convert the folder icon bitmap drawable to a bitmap.
 813             folderIconBitmap = folderIconBitmapDrawable.getBitmap();
 814         } else {  // Use the WebView favorite icon.
 815             // Copy the favorite icon bitmap to the folder icon bitmap.
 816             folderIconBitmap = favoriteIconBitmap;
 817         }
 818
 819         // Create a folder icon byte array output stream.
 820         ByteArrayOutputStream folderIconByteArrayOutputStream = new ByteArrayOutputStream();
 821
 822         // Convert the folder icon bitmap to a byte array.  `0` is for lossless compression (the only option for a PNG).
 823         folderIconBitmap.compress(Bitmap.CompressFormat.PNG, 0, folderIconByteArrayOutputStream);
 824
 825         // Convert the folder icon byte array stream to a byte array.
 826         byte[] folderIconByteArray = folderIconByteArrayOutputStream.toByteArray();
 827
 828         // Move all the bookmarks down one in the display order.
 829         for (int i = 0; i < bookmarksListView.getCount(); i++) {
 830             int databaseId = (int) bookmarksListView.getItemIdAtPosition(i);
 831             bookmarksDatabaseHelper.updateDisplayOrder(databaseId, i + 1);
 832         }
 833
 834         // Create the folder, which will be placed at the top of the `ListView`.
 835         bookmarksDatabaseHelper.createFolder(folderNameString, currentFolder, folderIconByteArray);
 836
 837         // Update the bookmarks cursor with the current contents of this folder.
 838         bookmarksCursor = bookmarksDatabaseHelper.getBookmarksByDisplayOrder(currentFolder);
 839
 840         // Update the list view.
 841         bookmarksCursorAdapter.changeCursor(bookmarksCursor);
 842
 843         // Scroll to the new folder.
 844         bookmarksListView.setSelection(0);
 845     }
 846
 847     @Override
 848     public void onSaveBookmark(DialogFragment dialogFragment, int selectedBookmarkDatabaseId, @NonNull Bitmap favoriteIconBitmap) {
 849         // Get the dialog from the dialog fragment.
 850         Dialog dialog = dialogFragment.getDialog();
 851
 852         // Remove the incorrect lint warning below that the dialog might be null.
 853         assert dialog != null;
 854
 855         // Get handles for the views from the dialog fragment.
 856         EditText bookmarkNameEditText = dialog.findViewById(R.id.bookmark_name_edittext);
 857         EditText bookmarkUrlEditText = dialog.findViewById(R.id.bookmark_url_edittext);
 858         RadioButton currentIconRadioButton = dialog.findViewById(R.id.current_icon_radiobutton);
 859
 860         // Store the bookmark strings.
 861         String bookmarkNameString = bookmarkNameEditText.getText().toString();
 862         String bookmarkUrlString = bookmarkUrlEditText.getText().toString();
 863
 864         // Update the bookmark.
 865         if (currentIconRadioButton.isChecked()) {  // Update the bookmark without changing the favorite icon.
 866             bookmarksDatabaseHelper.updateBookmark(selectedBookmarkDatabaseId, bookmarkNameString, bookmarkUrlString);
 867         } else {  // Update the bookmark using the WebView favorite icon.
 868             // Create a favorite icon byte array output stream.
 869             ByteArrayOutputStream newFavoriteIconByteArrayOutputStream = new ByteArrayOutputStream();
 870
 871             // Convert the favorite icon bitmap to a byte array.  `0` is for lossless compression (the only option for a PNG).
 872             favoriteIconBitmap.compress(Bitmap.CompressFormat.PNG, 0, newFavoriteIconByteArrayOutputStream);
 873
 874             // Convert the favorite icon byte array stream to a byte array.
 875             byte[] newFavoriteIconByteArray = newFavoriteIconByteArrayOutputStream.toByteArray();
 876
 877             //  Update the bookmark and the favorite icon.
 878             bookmarksDatabaseHelper.updateBookmark(selectedBookmarkDatabaseId, bookmarkNameString, bookmarkUrlString, newFavoriteIconByteArray);
 879         }
 880
 881         // Check to see if the contextual action mode has been created.
 882         if (contextualActionMode != null) {
 883             // Close the contextual action mode if it is open.
 884             contextualActionMode.finish();
 885         }
 886
 887         // Update the bookmarks cursor with the contents of the current folder.
 888         bookmarksCursor = bookmarksDatabaseHelper.getBookmarksByDisplayOrder(currentFolder);
 889
 890         // Update the `ListView`.
 891         bookmarksCursorAdapter.changeCursor(bookmarksCursor);
 892     }
 893
 894     @Override
 895     public void onSaveBookmarkFolder(DialogFragment dialogFragment, int selectedFolderDatabaseId, @NonNull Bitmap favoriteIconBitmap) {
 896         // Get the dialog from the dialog fragment.
 897         Dialog dialog = dialogFragment.getDialog();
 898
 899         // Remove the incorrect lint warning below that the dialog might be null.
 900         assert dialog != null;
 901
 902         // Get handles for the views from the dialog fragment.
 903         RadioButton currentFolderIconRadioButton = dialog.findViewById(R.id.current_icon_radiobutton);
 904         RadioButton defaultFolderIconRadioButton = dialog.findViewById(R.id.default_icon_radiobutton);
 905         ImageView defaultFolderIconImageView = dialog.findViewById(R.id.default_icon_imageview);
 906         EditText editFolderNameEditText = dialog.findViewById(R.id.folder_name_edittext);
 907
 908         // Get the new folder name.
 909         String newFolderNameString = editFolderNameEditText.getText().toString();
 910
 911         // Check if the favorite icon has changed.
 912         if (currentFolderIconRadioButton.isChecked()) {  // Only the name has changed.
 913             // Update the name in the database.
 914             bookmarksDatabaseHelper.updateFolder(selectedFolderDatabaseId, oldFolderNameString, newFolderNameString);
 915         } else if (!currentFolderIconRadioButton.isChecked() && newFolderNameString.equals(oldFolderNameString)) {  // Only the icon has changed.
 916             // Create the new folder icon Bitmap.
 917             Bitmap folderIconBitmap;
 918
 919             // Populate the new folder icon bitmap.
 920             if (defaultFolderIconRadioButton.isChecked()) {
 921                 // Get the default folder icon drawable.
 922                 Drawable folderIconDrawable = defaultFolderIconImageView.getDrawable();
 923
 924                 // Convert the folder icon drawable to a bitmap drawable.
 925                 BitmapDrawable folderIconBitmapDrawable = (BitmapDrawable) folderIconDrawable;
 926
 927                 // Convert the folder icon bitmap drawable to a bitmap.
 928                 folderIconBitmap = folderIconBitmapDrawable.getBitmap();
 929             } else {  // Use the WebView favorite icon.
 930                 // Copy the favorite icon bitmap to the folder icon bitmap.
 931                 folderIconBitmap = favoriteIconBitmap;
 932             }
 933
 934             // Create a folder icon byte array output stream.
 935             ByteArrayOutputStream newFolderIconByteArrayOutputStream = new ByteArrayOutputStream();
 936
 937             // Convert the folder icon bitmap to a byte array.  `0` is for lossless compression (the only option for a PNG).
 938             folderIconBitmap.compress(Bitmap.CompressFormat.PNG, 0, newFolderIconByteArrayOutputStream);
 939
 940             // Convert the folder icon byte array stream to a byte array.
 941             byte[] newFolderIconByteArray = newFolderIconByteArrayOutputStream.toByteArray();
 942
 943             // Update the folder icon in the database.
 944             bookmarksDatabaseHelper.updateFolder(selectedFolderDatabaseId, newFolderIconByteArray);
 945         } else {  // The folder icon and the name have changed.
 946             // Instantiate the new folder icon `Bitmap`.
 947             Bitmap folderIconBitmap;
 948
 949             // Populate the new folder icon bitmap.
 950             if (defaultFolderIconRadioButton.isChecked()) {
 951                 // Get the default folder icon drawable.
 952                 Drawable folderIconDrawable = defaultFolderIconImageView.getDrawable();
 953
 954                 // Convert the folder icon drawable to a bitmap drawable.
 955                 BitmapDrawable folderIconBitmapDrawable = (BitmapDrawable) folderIconDrawable;
 956
 957                 // Convert the folder icon bitmap drawable to a bitmap.
 958                 folderIconBitmap = folderIconBitmapDrawable.getBitmap();
 959             } else {  // Use the WebView favorite icon.
 960                 // Copy the favorite icon bitmap to the folder icon bitmap.
 961                 folderIconBitmap = favoriteIconBitmap;
 962             }
 963
 964             // Create a folder icon byte array output stream.
 965             ByteArrayOutputStream newFolderIconByteArrayOutputStream = new ByteArrayOutputStream();
 966
 967             // Convert the folder icon bitmap to a byte array.  `0` is for lossless compression (the only option for a PNG).
 968             folderIconBitmap.compress(Bitmap.CompressFormat.PNG, 0, newFolderIconByteArrayOutputStream);
 969
 970             // Convert the folder icon byte array stream to a byte array.
 971             byte[] newFolderIconByteArray = newFolderIconByteArrayOutputStream.toByteArray();
 972
 973             // Update the folder name and icon in the database.
 974             bookmarksDatabaseHelper.updateFolder(selectedFolderDatabaseId, oldFolderNameString, newFolderNameString, newFolderIconByteArray);
 975         }
 976
 977         // Update the bookmarks cursor with the current contents of this folder.
 978         bookmarksCursor = bookmarksDatabaseHelper.getBookmarksByDisplayOrder(currentFolder);
 979
 980         // Update the `ListView`.
 981         bookmarksCursorAdapter.changeCursor(bookmarksCursor);
 982
 983         // Close the contextual action mode.
 984         contextualActionMode.finish();
 985     }
 986
 987     @Override
 988     public void onMoveToFolder(DialogFragment dialogFragment) {
 989         // Get the dialog from the dialog fragment.
 990         Dialog dialog = dialogFragment.getDialog();
 991
 992         // Remove the incorrect lint warning below that the dialog might be null.
 993         assert dialog != null;
 994
 995         // Get a handle for the list view from the dialog.
 996         ListView folderListView = dialog.findViewById(R.id.move_to_folder_listview);
 997
 998         // Store a long array of the selected folders.
 999         long[] newFolderLongArray = folderListView.getCheckedItemIds();
1000
1001         // Get the new folder database ID.  Only one folder will be selected.
1002         int newFolderDatabaseId = (int) newFolderLongArray[0];
1003
1004         // Instantiate `newFolderName`.
1005         String newFolderName;
1006
1007         // Set the new folder name.
1008         if (newFolderDatabaseId == 0) {
1009             // The new folder is the home folder, represented as `""` in the database.
1010             newFolderName = "";
1011         } else {
1012             // Get the new folder name from the database.
1013             newFolderName = bookmarksDatabaseHelper.getFolderName(newFolderDatabaseId);
1014         }
1015
1016         // Get a long array with the the database ID of the selected bookmarks.
1017         long[] selectedBookmarksLongArray = bookmarksListView.getCheckedItemIds();
1018
1019         // Move each of the selected bookmarks to the new folder.
1020         for (long databaseIdLong : selectedBookmarksLongArray) {
1021             // Get `databaseIdInt` for each selected bookmark.
1022             int databaseIdInt = (int) databaseIdLong;
1023
1024             // Move the selected bookmark to the new folder.
1025             bookmarksDatabaseHelper.moveToFolder(databaseIdInt, newFolderName);
1026         }
1027
1028         // Update the bookmarks cursor with the current contents of this folder.
1029         bookmarksCursor = bookmarksDatabaseHelper.getBookmarksByDisplayOrder(currentFolder);
1030
1031         // Update the `ListView`.
1032         bookmarksCursorAdapter.changeCursor(bookmarksCursor);
1033
1034         // Close the contextual app bar.
1035         contextualActionMode.finish();
1036     }
1037
1038     private int countBookmarkFolderContents(int databaseId) {
1039         // Initialize the bookmark counter.
1040         int bookmarkCounter = 0;
1041
1042         // Get the name of the folder.
1043         String folderName = bookmarksDatabaseHelper.getFolderName(databaseId);
1044
1045         // Get the contents of the folder.
1046         Cursor folderCursor = bookmarksDatabaseHelper.getBookmarkIds(folderName);
1047
1048         // Count each of the bookmarks in the folder.
1049         for (int i = 0; i < folderCursor.getCount(); i++) {
1050             // Move the folder cursor to the current row.
1051             folderCursor.moveToPosition(i);
1052
1053             // Get the database ID of the item.
1054             int itemDatabaseId = folderCursor.getInt(folderCursor.getColumnIndexOrThrow(BookmarksDatabaseHelper.ID));
1055
1056             // If this is a folder, recursively count the contents first.
1057             if (bookmarksDatabaseHelper.isFolder(itemDatabaseId)) {
1058                 // Add the bookmarks from the folder to the running total.
1059                 bookmarkCounter = bookmarkCounter + countBookmarkFolderContents(itemDatabaseId);
1060             }
1061
1062             // Add the bookmark to the running total.
1063             bookmarkCounter++;
1064         }
1065
1066         // Return the bookmark counter.
1067         return bookmarkCounter;
1068     }
1069
1070     private void deleteBookmarkFolderContents(int databaseId) {
1071         // Get the name of the folder.
1072         String folderName = bookmarksDatabaseHelper.getFolderName(databaseId);
1073
1074         // Get the contents of the folder.
1075         Cursor folderCursor = bookmarksDatabaseHelper.getBookmarkIds(folderName);
1076
1077         // Delete each of the bookmarks in the folder.
1078         for (int i = 0; i < folderCursor.getCount(); i++) {
1079             // Move the folder cursor to the current row.
1080             folderCursor.moveToPosition(i);
1081
1082             // Get the database ID of the item.
1083             int itemDatabaseId = folderCursor.getInt(folderCursor.getColumnIndexOrThrow(BookmarksDatabaseHelper.ID));
1084
1085             // If this is a folder, recursively delete the contents first.
1086             if (bookmarksDatabaseHelper.isFolder(itemDatabaseId)) {
1087                 deleteBookmarkFolderContents(itemDatabaseId);
1088             }
1089
1090             // Delete the bookmark.
1091             bookmarksDatabaseHelper.deleteBookmark(itemDatabaseId);
1092         }
1093     }
1094
1095     private void updateMoveIcons() {
1096         // Get a long array of the selected bookmarks.
1097         long[] selectedBookmarksLongArray = bookmarksListView.getCheckedItemIds();
1098
1099         // Get the database IDs for the first, last, and selected bookmarks.
1100         int selectedBookmarkDatabaseId = (int) selectedBookmarksLongArray[0];
1101         int firstBookmarkDatabaseId = (int) bookmarksListView.getItemIdAtPosition(0);
1102         // bookmarksListView is 0 indexed.
1103         int lastBookmarkDatabaseId = (int) bookmarksListView.getItemIdAtPosition(bookmarksListView.getCount() - 1);
1104
1105         // Update the move bookmark up menu item.
1106         if (selectedBookmarkDatabaseId == firstBookmarkDatabaseId) {  // The selected bookmark is in the first position.
1107             // Disable the move bookmark up menu item.
1108             moveBookmarkUpMenuItem.setEnabled(false);
1109
1110             //  Set the icon.
1111             moveBookmarkUpMenuItem.setIcon(R.drawable.move_up_disabled);
1112         } else {  // The selected bookmark is not in the first position.
1113             // Enable the move bookmark up menu item.
1114             moveBookmarkUpMenuItem.setEnabled(true);
1115
1116             // Set the icon according to the theme.
1117             moveBookmarkUpMenuItem.setIcon(R.drawable.move_up_enabled);
1118         }
1119
1120         // Update the move bookmark down menu item.
1121         if (selectedBookmarkDatabaseId == lastBookmarkDatabaseId) {  // The selected bookmark is in the last position.
1122             // Disable the move bookmark down menu item.
1123             moveBookmarkDownMenuItem.setEnabled(false);
1124
1125             // Set the icon.
1126             moveBookmarkDownMenuItem.setIcon(R.drawable.move_down_disabled);
1127         } else {  // The selected bookmark is not in the last position.
1128             // Enable the move bookmark down menu item.
1129             moveBookmarkDownMenuItem.setEnabled(true);
1130
1131             // Set the icon.
1132             moveBookmarkDownMenuItem.setIcon(R.drawable.move_down_enabled);
1133         }
1134     }
1135
1136     private void scrollBookmarks(int selectedBookmarkPosition) {
1137         // Get the first and last visible bookmark positions.
1138         int firstVisibleBookmarkPosition = bookmarksListView.getFirstVisiblePosition();
1139         int lastVisibleBookmarkPosition = bookmarksListView.getLastVisiblePosition();
1140
1141         // Calculate the number of bookmarks per screen.
1142         int numberOfBookmarksPerScreen = lastVisibleBookmarkPosition - firstVisibleBookmarkPosition;
1143
1144         // Scroll with the moved bookmark if necessary.
1145         if (selectedBookmarkPosition <= firstVisibleBookmarkPosition) {  // The selected bookmark position is at or above the top of the screen.
1146             // Scroll to the selected bookmark position.
1147             bookmarksListView.setSelection(selectedBookmarkPosition);
1148         } else if (selectedBookmarkPosition >= (lastVisibleBookmarkPosition - 1)) {  // The selected bookmark is at or below the bottom of the screen.
1149             // The `-1` handles partial bookmarks displayed at the bottom of the list view.  This command scrolls to display the selected bookmark at the bottom of the screen.
1150             // `+1` assures that the entire bookmark will be displayed in situations where only a partial bookmark fits at the bottom of the list view.
1151             bookmarksListView.setSelection(selectedBookmarkPosition - numberOfBookmarksPerScreen + 1);
1152         }
1153     }
1154
1155     private void loadFolder() {
1156         // Update bookmarks cursor with the contents of the bookmarks database for the current folder.
1157         bookmarksCursor = bookmarksDatabaseHelper.getBookmarksByDisplayOrder(currentFolder);
1158
1159         // Setup a `CursorAdapter`.  `this` specifies the `Context`.  `false` disables `autoRequery`.
1160         bookmarksCursorAdapter = new CursorAdapter(this, bookmarksCursor, false) {
1161             @Override
1162             public View newView(Context context, Cursor cursor, ViewGroup parent) {
1163                 // Inflate the individual item layout.  `false` does not attach it to the root.
1164                 return getLayoutInflater().inflate(R.layout.bookmarks_activity_item_linearlayout, parent, false);
1165             }
1166
1167             @Override
1168             public void bindView(View view, Context context, Cursor cursor) {
1169                 // Get handles for the views.
1170                 ImageView bookmarkFavoriteIcon = view.findViewById(R.id.bookmark_favorite_icon);
1171                 TextView bookmarkNameTextView = view.findViewById(R.id.bookmark_name);
1172
1173                 // Get the favorite icon byte array from the `Cursor`.
1174                 byte[] favoriteIconByteArray = cursor.getBlob(cursor.getColumnIndexOrThrow(BookmarksDatabaseHelper.FAVORITE_ICON));
1175
1176                 // Convert the byte array to a `Bitmap` beginning at the first byte and ending at the last.
1177                 Bitmap favoriteIconBitmap = BitmapFactory.decodeByteArray(favoriteIconByteArray, 0, favoriteIconByteArray.length);
1178
1179                 // Display the bitmap in `bookmarkFavoriteIcon`.
1180                 bookmarkFavoriteIcon.setImageBitmap(favoriteIconBitmap);
1181
1182                 // Get the bookmark name from the cursor and display it in `bookmarkNameTextView`.
1183                 String bookmarkNameString = cursor.getString(cursor.getColumnIndexOrThrow(BookmarksDatabaseHelper.BOOKMARK_NAME));
1184                 bookmarkNameTextView.setText(bookmarkNameString);
1185
1186                 // Make the font bold for folders.
1187                 if (cursor.getInt(cursor.getColumnIndexOrThrow(BookmarksDatabaseHelper.IS_FOLDER)) == 1) {
1188                     bookmarkNameTextView.setTypeface(Typeface.DEFAULT_BOLD);
1189                 } else {  // Reset the font to default for normal bookmarks.
1190                     bookmarkNameTextView.setTypeface(Typeface.DEFAULT);
1191                 }
1192             }
1193         };
1194
1195         // Populate the list view with the adapter.
1196         bookmarksListView.setAdapter(bookmarksCursorAdapter);
1197
1198         // Set the `AppBar` title.
1199         if (currentFolder.isEmpty()) {
1200             appBar.setTitle(R.string.bookmarks);
1201         } else {
1202             appBar.setTitle(currentFolder);
1203         }
1204     }
1205
1206     @Override
1207     public void onDestroy() {
1208         // Close the bookmarks cursor and database.
1209         bookmarksCursor.close();
1210         bookmarksDatabaseHelper.close();
1211
1212         // Run the default commands.
1213         super.onDestroy();
1214     }
1215 }