33687f9a48512202c96d3a5a5086fc49cee92d0b
[PrivacyBrowser.git] / app / src / main / java / com / stoutner / privacybrowser / activities / MainWebViewActivity.java
1 /*
2  * Copyright © 2015-2019 Soren Stoutner <soren@stoutner.com>.
3  *
4  * Download cookie code contributed 2017 Hendrik Knackstedt.  Copyright assigned to Soren Stoutner <soren@stoutner.com>.
5  *
6  * This file is part of Privacy Browser <https://www.stoutner.com/privacy-browser>.
7  *
8  * Privacy Browser is free software: you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation, either version 3 of the License, or
11  * (at your option) any later version.
12  *
13  * Privacy Browser is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with Privacy Browser.  If not, see <http://www.gnu.org/licenses/>.
20  */
21
22 package com.stoutner.privacybrowser.activities;
23
24 import android.Manifest;
25 import android.annotation.SuppressLint;
26 import android.app.Activity;
27 import android.app.DownloadManager;
28 import android.app.SearchManager;
29 import android.content.ActivityNotFoundException;
30 import android.content.BroadcastReceiver;
31 import android.content.ClipData;
32 import android.content.ClipboardManager;
33 import android.content.Context;
34 import android.content.Intent;
35 import android.content.IntentFilter;
36 import android.content.SharedPreferences;
37 import android.content.pm.PackageManager;
38 import android.content.res.Configuration;
39 import android.database.Cursor;
40 import android.graphics.Bitmap;
41 import android.graphics.BitmapFactory;
42 import android.graphics.Typeface;
43 import android.graphics.drawable.BitmapDrawable;
44 import android.graphics.drawable.Drawable;
45 import android.net.Uri;
46 import android.net.http.SslCertificate;
47 import android.net.http.SslError;
48 import android.os.Build;
49 import android.os.Bundle;
50 import android.os.Environment;
51 import android.os.Handler;
52 import android.preference.PreferenceManager;
53 import android.print.PrintDocumentAdapter;
54 import android.print.PrintManager;
55 import android.text.Editable;
56 import android.text.Spanned;
57 import android.text.TextWatcher;
58 import android.text.style.ForegroundColorSpan;
59 import android.util.Patterns;
60 import android.view.ContextMenu;
61 import android.view.GestureDetector;
62 import android.view.KeyEvent;
63 import android.view.Menu;
64 import android.view.MenuItem;
65 import android.view.MotionEvent;
66 import android.view.View;
67 import android.view.ViewGroup;
68 import android.view.WindowManager;
69 import android.view.inputmethod.InputMethodManager;
70 import android.webkit.CookieManager;
71 import android.webkit.HttpAuthHandler;
72 import android.webkit.SslErrorHandler;
73 import android.webkit.ValueCallback;
74 import android.webkit.WebChromeClient;
75 import android.webkit.WebResourceResponse;
76 import android.webkit.WebSettings;
77 import android.webkit.WebStorage;
78 import android.webkit.WebView;
79 import android.webkit.WebViewClient;
80 import android.webkit.WebViewDatabase;
81 import android.widget.ArrayAdapter;
82 import android.widget.CursorAdapter;
83 import android.widget.EditText;
84 import android.widget.FrameLayout;
85 import android.widget.ImageView;
86 import android.widget.LinearLayout;
87 import android.widget.ListView;
88 import android.widget.ProgressBar;
89 import android.widget.RadioButton;
90 import android.widget.RelativeLayout;
91 import android.widget.TextView;
92
93 import androidx.annotation.NonNull;
94 import androidx.appcompat.app.ActionBar;
95 import androidx.appcompat.app.ActionBarDrawerToggle;
96 import androidx.appcompat.app.AppCompatActivity;
97 import androidx.appcompat.widget.Toolbar;
98 import androidx.coordinatorlayout.widget.CoordinatorLayout;
99 import androidx.core.app.ActivityCompat;
100 import androidx.core.content.ContextCompat;
101 import androidx.core.view.GravityCompat;
102 import androidx.drawerlayout.widget.DrawerLayout;
103 import androidx.fragment.app.DialogFragment;
104 import androidx.fragment.app.FragmentManager;
105 import androidx.swiperefreshlayout.widget.SwipeRefreshLayout;
106 import androidx.viewpager.widget.ViewPager;
107
108 import com.google.android.material.appbar.AppBarLayout;
109 import com.google.android.material.floatingactionbutton.FloatingActionButton;
110 import com.google.android.material.navigation.NavigationView;
111 import com.google.android.material.snackbar.Snackbar;
112 import com.google.android.material.tabs.TabLayout;
113
114 import com.stoutner.privacybrowser.BuildConfig;
115 import com.stoutner.privacybrowser.R;
116 import com.stoutner.privacybrowser.adapters.WebViewPagerAdapter;
117 import com.stoutner.privacybrowser.asynctasks.GetHostIpAddresses;
118 import com.stoutner.privacybrowser.asynctasks.PopulateBlocklists;
119 import com.stoutner.privacybrowser.dialogs.AdConsentDialog;
120 import com.stoutner.privacybrowser.dialogs.CreateBookmarkDialog;
121 import com.stoutner.privacybrowser.dialogs.CreateBookmarkFolderDialog;
122 import com.stoutner.privacybrowser.dialogs.CreateHomeScreenShortcutDialog;
123 import com.stoutner.privacybrowser.dialogs.DownloadFileDialog;
124 import com.stoutner.privacybrowser.dialogs.DownloadImageDialog;
125 import com.stoutner.privacybrowser.dialogs.DownloadLocationPermissionDialog;
126 import com.stoutner.privacybrowser.dialogs.EditBookmarkDialog;
127 import com.stoutner.privacybrowser.dialogs.EditBookmarkFolderDialog;
128 import com.stoutner.privacybrowser.dialogs.HttpAuthenticationDialog;
129 import com.stoutner.privacybrowser.dialogs.SslCertificateErrorDialog;
130 import com.stoutner.privacybrowser.dialogs.UrlHistoryDialog;
131 import com.stoutner.privacybrowser.dialogs.ViewSslCertificateDialog;
132 import com.stoutner.privacybrowser.fragments.WebViewTabFragment;
133 import com.stoutner.privacybrowser.helpers.AdHelper;
134 import com.stoutner.privacybrowser.helpers.BlockListHelper;
135 import com.stoutner.privacybrowser.helpers.BookmarksDatabaseHelper;
136 import com.stoutner.privacybrowser.helpers.CheckPinnedMismatchHelper;
137 import com.stoutner.privacybrowser.helpers.DomainsDatabaseHelper;
138 import com.stoutner.privacybrowser.helpers.OrbotProxyHelper;
139 import com.stoutner.privacybrowser.views.NestedScrollWebView;
140
141 import java.io.ByteArrayInputStream;
142 import java.io.ByteArrayOutputStream;
143 import java.io.File;
144 import java.io.IOException;
145 import java.io.UnsupportedEncodingException;
146 import java.net.MalformedURLException;
147 import java.net.URL;
148 import java.net.URLDecoder;
149 import java.net.URLEncoder;
150 import java.util.ArrayList;
151 import java.util.Date;
152 import java.util.HashMap;
153 import java.util.HashSet;
154 import java.util.List;
155 import java.util.Map;
156 import java.util.Set;
157
158 // AppCompatActivity from android.support.v7.app.AppCompatActivity must be used to have access to the SupportActionBar until the minimum API is >= 21.
159 public class MainWebViewActivity extends AppCompatActivity implements CreateBookmarkDialog.CreateBookmarkListener, CreateBookmarkFolderDialog.CreateBookmarkFolderListener,
160         DownloadFileDialog.DownloadFileListener, DownloadImageDialog.DownloadImageListener, DownloadLocationPermissionDialog.DownloadLocationPermissionDialogListener, EditBookmarkDialog.EditBookmarkListener,
161         EditBookmarkFolderDialog.EditBookmarkFolderListener, NavigationView.OnNavigationItemSelectedListener, PopulateBlocklists.PopulateBlocklistsListener, WebViewTabFragment.NewTabListener {
162
163     // `orbotStatus` is public static so it can be accessed from `OrbotProxyHelper`.  It is also used in `onCreate()`, `onResume()`, and `applyProxyThroughOrbot()`.
164     public static String orbotStatus;
165
166     // The WebView pager adapter is accessed from `HttpAuthenticationDialog`, `PinnedMismatchDialog`, and `SslCertificateErrorDialog`.  It is also used in `onCreate()`, `onResume()`, and `addTab()`.
167     public static WebViewPagerAdapter webViewPagerAdapter;
168
169     // The load URL on restart variables are public static so they can be accessed from `BookmarksActivity`.  They are used in `onRestart()`.
170     public static boolean loadUrlOnRestart;
171     public static String urlToLoadOnRestart;
172
173     // `restartFromBookmarksActivity` is public static so it can be accessed from `BookmarksActivity`.  It is also used in `onRestart()`.
174     public static boolean restartFromBookmarksActivity;
175
176     // `currentBookmarksFolder` is public static so it can be accessed from `BookmarksActivity`.  It is also used in `onCreate()`, `onBackPressed()`, `onCreateBookmark()`, `onCreateBookmarkFolder()`,
177     // `onSaveEditBookmark()`, `onSaveEditBookmarkFolder()`, and `loadBookmarksFolder()`.
178     public static String currentBookmarksFolder;
179
180     // The user agent constants are public static so they can be accessed from `SettingsFragment`, `DomainsActivity`, and `DomainSettingsFragment`.
181     public final static int UNRECOGNIZED_USER_AGENT = -1;
182     public final static int SETTINGS_WEBVIEW_DEFAULT_USER_AGENT = 1;
183     public final static int SETTINGS_CUSTOM_USER_AGENT = 12;
184     public final static int DOMAINS_SYSTEM_DEFAULT_USER_AGENT = 0;
185     public final static int DOMAINS_WEBVIEW_DEFAULT_USER_AGENT = 2;
186     public final static int DOMAINS_CUSTOM_USER_AGENT = 13;
187
188
189
190     // The current WebView is used in `onCreate()`, `onPrepareOptionsMenu()`, `onOptionsItemSelected()`, `onNavigationItemSelected()`, `onRestart()`, `onCreateContextMenu()`, `findPreviousOnPage()`,
191     // `findNextOnPage()`, `closeFindOnPage()`, `loadUrlFromTextBox()`, `onSslMismatchBack()`, `applyProxyThroughOrbot()`, and `applyDomainSettings()`.
192     private NestedScrollWebView currentWebView;
193
194     // `customHeader` is used in `onCreate()`, `onOptionsItemSelected()`, `onCreateContextMenu()`, and `loadUrl()`.
195     private final Map<String, String> customHeaders = new HashMap<>();
196
197     // The search URL is set in `applyProxyThroughOrbot()` and used in `onCreate()`, `onNewIntent()`, `loadURLFromTextBox()`, and `initializeWebView()`.
198     private String searchURL;
199
200     // The options menu is set in `onCreateOptionsMenu()` and used in `onOptionsItemSelected()`, `updatePrivacyIcons()`, and `initializeWebView()`.
201     private Menu optionsMenu;
202
203     // The blocklists are populated in `finishedPopulatingBlocklists()` and accessed from `initializeWebView()`.
204     private ArrayList<List<String[]>> easyList;
205     private ArrayList<List<String[]>> easyPrivacy;
206     private ArrayList<List<String[]>> fanboysAnnoyanceList;
207     private ArrayList<List<String[]>> fanboysSocialList;
208     private ArrayList<List<String[]>> ultraPrivacy;
209
210     // `webViewDefaultUserAgent` is used in `onCreate()` and `onPrepareOptionsMenu()`.
211     private String webViewDefaultUserAgent;
212
213     // `proxyThroughOrbot` is used in `onRestart()`, `onOptionsItemSelected()`, `applyAppSettings()`, and `applyProxyThroughOrbot()`.
214     private boolean proxyThroughOrbot;
215
216     // The incognito mode is set in `applyAppSettings()` and used in `initializeWebView()`.
217     private boolean incognitoModeEnabled;
218
219     // The full screen browsing mode tracker is set it `applyAppSettings()` and used in `initializeWebView()`.
220     private boolean fullScreenBrowsingModeEnabled;
221
222     // `inFullScreenBrowsingMode` is used in `onCreate()`, `onConfigurationChanged()`, and `applyAppSettings()`.
223     private boolean inFullScreenBrowsingMode;
224
225     // The app bar trackers are set in `applyAppSettings()` and used in `initializeWebView()`.
226     private boolean hideAppBar;
227     private boolean scrollAppBar;
228
229     // The loading new intent tracker is set in `onNewIntent()` and used in `setCurrentWebView()`.
230     private boolean loadingNewIntent;
231
232     // `reapplyDomainSettingsOnRestart` is used in `onCreate()`, `onOptionsItemSelected()`, `onNavigationItemSelected()`, `onRestart()`, and `onAddDomain()`, .
233     private boolean reapplyDomainSettingsOnRestart;
234
235     // `reapplyAppSettingsOnRestart` is used in `onNavigationItemSelected()` and `onRestart()`.
236     private boolean reapplyAppSettingsOnRestart;
237
238     // `displayingFullScreenVideo` is used in `onCreate()` and `onResume()`.
239     private boolean displayingFullScreenVideo;
240
241     // `orbotStatusBroadcastReceiver` is used in `onCreate()` and `onDestroy()`.
242     private BroadcastReceiver orbotStatusBroadcastReceiver;
243
244     // `waitingForOrbot` is used in `onCreate()`, `onResume()`, and `applyProxyThroughOrbot()`.
245     private boolean waitingForOrbot;
246
247     // The action bar drawer toggle is initialized in `onCreate()` and used in `onResume()`.
248     private ActionBarDrawerToggle actionBarDrawerToggle;
249
250     // The color spans are used in `onCreate()` and `highlightUrlText()`.
251     private ForegroundColorSpan redColorSpan;
252     private ForegroundColorSpan initialGrayColorSpan;
253     private ForegroundColorSpan finalGrayColorSpan;
254
255     // The drawer header padding variables are used in `onCreate()` and `onConfigurationChanged()`.
256     private int drawerHeaderPaddingLeftAndRight;
257     private int drawerHeaderPaddingTop;
258     private int drawerHeaderPaddingBottom;
259
260     // `bookmarksDatabaseHelper` is used in `onCreate()`, `onDestroy`, `onOptionsItemSelected()`, `onCreateBookmark()`, `onCreateBookmarkFolder()`, `onSaveEditBookmark()`, `onSaveEditBookmarkFolder()`,
261     // and `loadBookmarksFolder()`.
262     private BookmarksDatabaseHelper bookmarksDatabaseHelper;
263
264     // `bookmarksCursor` is used in `onDestroy()`, `onOptionsItemSelected()`, `onCreateBookmark()`, `onCreateBookmarkFolder()`, `onSaveEditBookmark()`, `onSaveEditBookmarkFolder()`, and `loadBookmarksFolder()`.
265     private Cursor bookmarksCursor;
266
267     // `bookmarksCursorAdapter` is used in `onCreateBookmark()`, `onCreateBookmarkFolder()` `onSaveEditBookmark()`, `onSaveEditBookmarkFolder()`, and `loadBookmarksFolder()`.
268     private CursorAdapter bookmarksCursorAdapter;
269
270     // `oldFolderNameString` is used in `onCreate()` and `onSaveEditBookmarkFolder()`.
271     private String oldFolderNameString;
272
273     // `fileChooserCallback` is used in `onCreate()` and `onActivityResult()`.
274     private ValueCallback<Uri[]> fileChooserCallback;
275
276     // The default progress view offsets are set in `onCreate()` and used in `initializeWebView()`.
277     private int defaultProgressViewStartOffset;
278     private int defaultProgressViewEndOffset;
279
280     // The swipe refresh layout top padding is used when exiting full screen browsing mode.  It is used in an inner class in `initializeWebView()`.
281     private int swipeRefreshLayoutPaddingTop;
282
283     // The URL sanitizers are set in `applyAppSettings()` and used in `sanitizeUrl()`.
284     private boolean sanitizeGoogleAnalytics;
285     private boolean sanitizeFacebookClickIds;
286     private boolean sanitizeTwitterAmpRedirects;
287
288     // The download strings are used in `onCreate()`, `onRequestPermissionResult()` and `initializeWebView()`.
289     private String downloadUrl;
290     private String downloadContentDisposition;
291     private long downloadContentLength;
292
293     // `downloadImageUrl` is used in `onCreateContextMenu()` and `onRequestPermissionResult()`.
294     private String downloadImageUrl;
295
296     // The request codes are used in `onCreate()`, `onCreateContextMenu()`, `onCloseDownloadLocationPermissionDialog()`, `onRequestPermissionResult()`, and `initializeWebView()`.
297     private final int DOWNLOAD_FILE_REQUEST_CODE = 1;
298     private final int DOWNLOAD_IMAGE_REQUEST_CODE = 2;
299
300     @Override
301     // Remove the warning about needing to override `performClick()` when using an `OnTouchListener` with `WebView`.
302     @SuppressLint("ClickableViewAccessibility")
303     protected void onCreate(Bundle savedInstanceState) {
304         // Get a handle for the shared preferences.
305         SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(this);
306
307         // Get the theme and screenshot preferences.
308         boolean darkTheme = sharedPreferences.getBoolean("dark_theme", false);
309         boolean allowScreenshots = sharedPreferences.getBoolean("allow_screenshots", false);
310
311         // Disable screenshots if not allowed.
312         if (!allowScreenshots) {
313             getWindow().addFlags(WindowManager.LayoutParams.FLAG_SECURE);
314         }
315
316         // Set the activity theme.
317         if (darkTheme) {
318             setTheme(R.style.PrivacyBrowserDark);
319         } else {
320             setTheme(R.style.PrivacyBrowserLight);
321         }
322
323         // Run the default commands.
324         super.onCreate(savedInstanceState);
325
326         // Set the content view.
327         setContentView(R.layout.main_framelayout);
328
329         // Get a handle for the input method.
330         InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
331
332         // Remove the lint warning below that the input method manager might be null.
333         assert inputMethodManager != null;
334
335         // Get a handle for the toolbar.
336         Toolbar toolbar = findViewById(R.id.toolbar);
337
338         // Set the action bar.  `SupportActionBar` must be used until the minimum API is >= 21.
339         setSupportActionBar(toolbar);
340
341         // Get a handle for the action bar.
342         ActionBar actionBar = getSupportActionBar();
343
344         // This is needed to get rid of the Android Studio warning that the action bar might be null.
345         assert actionBar != null;
346
347         // Add the custom layout, which shows the URL text bar.
348         actionBar.setCustomView(R.layout.url_app_bar);
349         actionBar.setDisplayOptions(ActionBar.DISPLAY_SHOW_CUSTOM);
350
351         // Initialize the foreground color spans for highlighting the URLs.  We have to use the deprecated `getColor()` until API >= 23.
352         redColorSpan = new ForegroundColorSpan(getResources().getColor(R.color.red_a700));
353         initialGrayColorSpan = new ForegroundColorSpan(getResources().getColor(R.color.gray_500));
354         finalGrayColorSpan = new ForegroundColorSpan(getResources().getColor(R.color.gray_500));
355
356         // Get handles for the URL views.
357         EditText urlEditText = findViewById(R.id.url_edittext);
358
359         // Remove the formatting from `urlTextBar` when the user is editing the text.
360         urlEditText.setOnFocusChangeListener((View v, boolean hasFocus) -> {
361             if (hasFocus) {  // The user is editing the URL text box.
362                 // Remove the highlighting.
363                 urlEditText.getText().removeSpan(redColorSpan);
364                 urlEditText.getText().removeSpan(initialGrayColorSpan);
365                 urlEditText.getText().removeSpan(finalGrayColorSpan);
366             } else {  // The user has stopped editing the URL text box.
367                 // Move to the beginning of the string.
368                 urlEditText.setSelection(0);
369
370                 // Reapply the highlighting.
371                 highlightUrlText();
372             }
373         });
374
375         // Set the go button on the keyboard to load the URL in `urlTextBox`.
376         urlEditText.setOnKeyListener((View v, int keyCode, KeyEvent event) -> {
377             // If the event is a key-down event on the `enter` button, load the URL.
378             if ((event.getAction() == KeyEvent.ACTION_DOWN) && (keyCode == KeyEvent.KEYCODE_ENTER)) {
379                 // Load the URL into the mainWebView and consume the event.
380                 loadUrlFromTextBox();
381
382                 // If the enter key was pressed, consume the event.
383                 return true;
384             } else {
385                 // If any other key was pressed, do not consume the event.
386                 return false;
387             }
388         });
389
390         // Initialize the Orbot status and the waiting for Orbot trackers.
391         orbotStatus = "unknown";
392         waitingForOrbot = false;
393
394         // Create an Orbot status `BroadcastReceiver`.
395         orbotStatusBroadcastReceiver = new BroadcastReceiver() {
396             @Override
397             public void onReceive(Context context, Intent intent) {
398                 // Store the content of the status message in `orbotStatus`.
399                 orbotStatus = intent.getStringExtra("org.torproject.android.intent.extra.STATUS");
400
401                 // If Privacy Browser is waiting on Orbot, load the website now that Orbot is connected.
402                 if (orbotStatus.equals("ON") && waitingForOrbot) {
403                     // Reset the waiting for Orbot status.
404                     waitingForOrbot = false;
405
406                     // Get the intent that started the app.
407                     Intent launchingIntent = getIntent();
408
409                     // Get the information from the intent.
410                     String launchingIntentAction = launchingIntent.getAction();
411                     Uri launchingIntentUriData = launchingIntent.getData();
412
413                     // If the intent action is a web search, perform the search.
414                     if ((launchingIntentAction != null) && launchingIntentAction.equals(Intent.ACTION_WEB_SEARCH)) {
415                         // Create an encoded URL string.
416                         String encodedUrlString;
417
418                         // Sanitize the search input and convert it to a search.
419                         try {
420                             encodedUrlString = URLEncoder.encode(launchingIntent.getStringExtra(SearchManager.QUERY), "UTF-8");
421                         } catch (UnsupportedEncodingException exception) {
422                             encodedUrlString = "";
423                         }
424
425                         // Load the completed search URL.
426                         loadUrl(searchURL + encodedUrlString);
427                     } else if (launchingIntentUriData != null){  // Check to see if the intent contains a new URL.
428                         // Load the URL from the intent.
429                         loadUrl(launchingIntentUriData.toString());
430                     } else {  // The is no URL in the intent.
431                         // Select the homepage based on the proxy through Orbot status.
432                         if (proxyThroughOrbot) {
433                             // Load the Tor homepage.
434                             loadUrl(sharedPreferences.getString("tor_homepage", getString(R.string.tor_homepage_default_value)));
435                         } else {
436                             // Load the normal homepage.
437                             loadUrl(sharedPreferences.getString("homepage", getString(R.string.homepage_default_value)));
438                         }
439                     }
440                 }
441             }
442         };
443
444         // Register `orbotStatusBroadcastReceiver` on `this` context.
445         this.registerReceiver(orbotStatusBroadcastReceiver, new IntentFilter("org.torproject.android.intent.action.STATUS"));
446
447         // Get handles for views that need to be modified.
448         DrawerLayout drawerLayout = findViewById(R.id.drawerlayout);
449         NavigationView navigationView = findViewById(R.id.navigationview);
450         TabLayout tabLayout = findViewById(R.id.tablayout);
451         SwipeRefreshLayout swipeRefreshLayout = findViewById(R.id.swiperefreshlayout);
452         ViewPager webViewPager = findViewById(R.id.webviewpager);
453         ListView bookmarksListView = findViewById(R.id.bookmarks_drawer_listview);
454         FloatingActionButton launchBookmarksActivityFab = findViewById(R.id.launch_bookmarks_activity_fab);
455         FloatingActionButton createBookmarkFolderFab = findViewById(R.id.create_bookmark_folder_fab);
456         FloatingActionButton createBookmarkFab = findViewById(R.id.create_bookmark_fab);
457         EditText findOnPageEditText = findViewById(R.id.find_on_page_edittext);
458
459         // Listen for touches on the navigation menu.
460         navigationView.setNavigationItemSelectedListener(this);
461
462         // Get handles for the navigation menu and the back and forward menu items.  The menu is zero-based.
463         Menu navigationMenu = navigationView.getMenu();
464         MenuItem navigationBackMenuItem = navigationMenu.getItem(2);
465         MenuItem navigationForwardMenuItem = navigationMenu.getItem(3);
466         MenuItem navigationHistoryMenuItem = navigationMenu.getItem(4);
467         MenuItem navigationRequestsMenuItem = navigationMenu.getItem(5);
468
469         // Initialize the web view pager adapter.
470         webViewPagerAdapter = new WebViewPagerAdapter(getSupportFragmentManager());
471
472         // Set the pager adapter on the web view pager.
473         webViewPager.setAdapter(webViewPagerAdapter);
474
475         // Store up to 100 tabs in memory.
476         webViewPager.setOffscreenPageLimit(100);
477
478         // Update the web view pager every time a tab is modified.
479         webViewPager.addOnPageChangeListener(new ViewPager.OnPageChangeListener() {
480             @Override
481             public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) {
482                 // Do nothing.
483             }
484
485             @Override
486             public void onPageSelected(int position) {
487                 // Close the find on page bar if it is open.
488                 closeFindOnPage(null);
489
490                 // Set the current WebView.
491                 setCurrentWebView(position);
492
493                 // Select the corresponding tab if it does not match the currently selected page.  This will happen if the page was scrolled via swiping in the view pager or by creating a new tab.
494                 if (tabLayout.getSelectedTabPosition() != position) {
495                     // Create a handler to select the tab.
496                     Handler selectTabHandler = new Handler();
497
498                     // Create a runnable to select the tab.
499                     Runnable selectTabRunnable = () -> {
500                         // Get a handle for the tab.
501                         TabLayout.Tab tab = tabLayout.getTabAt(position);
502
503                         // Assert that the tab is not null.
504                         assert tab != null;
505
506                         // Select the tab.
507                         tab.select();
508                     };
509
510                     // Select the tab layout after 150 milliseconds, which leaves enough time for a new tab to be inflated.
511                     selectTabHandler.postDelayed(selectTabRunnable, 150);
512                 }
513             }
514
515             @Override
516             public void onPageScrollStateChanged(int state) {
517                 // Do nothing.
518             }
519         });
520
521         // Display the View SSL Certificate dialog when the currently selected tab is reselected.
522         tabLayout.addOnTabSelectedListener(new TabLayout.OnTabSelectedListener() {
523             @Override
524             public void onTabSelected(TabLayout.Tab tab) {
525                 // Select the same page in the view pager.
526                 webViewPager.setCurrentItem(tab.getPosition());
527             }
528
529             @Override
530             public void onTabUnselected(TabLayout.Tab tab) {
531                 // Do nothing.
532             }
533
534             @Override
535             public void onTabReselected(TabLayout.Tab tab) {
536                 // Instantiate the View SSL Certificate dialog.
537                 DialogFragment viewSslCertificateDialogFragment = ViewSslCertificateDialog.displayDialog(currentWebView.getWebViewFragmentId());
538
539                 // Display the View SSL Certificate dialog.
540                 viewSslCertificateDialogFragment.show(getSupportFragmentManager(), getString(R.string.view_ssl_certificate));
541             }
542         });
543
544         // Set the bookmarks drawer resources according to the theme.  This can't be done in the layout due to compatibility issues with the `DrawerLayout` support widget.
545         // The deprecated `getResources().getDrawable()` must be used until the minimum API >= 21 and and `getResources().getColor()` must be used until the minimum API >= 23.
546         if (darkTheme) {
547             launchBookmarksActivityFab.setImageDrawable(getResources().getDrawable(R.drawable.bookmarks_dark));
548             createBookmarkFolderFab.setImageDrawable(getResources().getDrawable(R.drawable.create_folder_dark));
549             createBookmarkFab.setImageDrawable(getResources().getDrawable(R.drawable.create_bookmark_dark));
550             bookmarksListView.setBackgroundColor(getResources().getColor(R.color.gray_850));
551         } else {
552             launchBookmarksActivityFab.setImageDrawable(getResources().getDrawable(R.drawable.bookmarks_light));
553             createBookmarkFolderFab.setImageDrawable(getResources().getDrawable(R.drawable.create_folder_light));
554             createBookmarkFab.setImageDrawable(getResources().getDrawable(R.drawable.create_bookmark_light));
555             bookmarksListView.setBackgroundColor(getResources().getColor(R.color.white));
556         }
557
558         // Set the launch bookmarks activity FAB to launch the bookmarks activity.
559         launchBookmarksActivityFab.setOnClickListener(v -> {
560             // Get a copy of the favorite icon bitmap.
561             Bitmap favoriteIconBitmap = currentWebView.getFavoriteOrDefaultIcon();
562
563             // Create a favorite icon byte array output stream.
564             ByteArrayOutputStream favoriteIconByteArrayOutputStream = new ByteArrayOutputStream();
565
566             // Convert the favorite icon bitmap to a byte array.  `0` is for lossless compression (the only option for a PNG).
567             favoriteIconBitmap.compress(Bitmap.CompressFormat.PNG, 0, favoriteIconByteArrayOutputStream);
568
569             // Convert the favorite icon byte array stream to a byte array.
570             byte[] favoriteIconByteArray = favoriteIconByteArrayOutputStream.toByteArray();
571
572             // Create an intent to launch the bookmarks activity.
573             Intent bookmarksIntent = new Intent(getApplicationContext(), BookmarksActivity.class);
574
575             // Add the extra information to the intent.
576             bookmarksIntent.putExtra("current_url", currentWebView.getUrl());
577             bookmarksIntent.putExtra("current_title", currentWebView.getTitle());
578             bookmarksIntent.putExtra("current_folder", currentBookmarksFolder);
579             bookmarksIntent.putExtra("favorite_icon_byte_array", favoriteIconByteArray);
580
581             // Make it so.
582             startActivity(bookmarksIntent);
583         });
584
585         // Set the create new bookmark folder FAB to display an alert dialog.
586         createBookmarkFolderFab.setOnClickListener(v -> {
587             // Create a create bookmark folder dialog.
588             DialogFragment createBookmarkFolderDialog = CreateBookmarkFolderDialog.createBookmarkFolder(currentWebView.getFavoriteOrDefaultIcon());
589
590             // Show the create bookmark folder dialog.
591             createBookmarkFolderDialog.show(getSupportFragmentManager(), getString(R.string.create_folder));
592         });
593
594         // Set the create new bookmark FAB to display an alert dialog.
595         createBookmarkFab.setOnClickListener(view -> {
596             // Instantiate the create bookmark dialog.
597             DialogFragment createBookmarkDialog = CreateBookmarkDialog.createBookmark(currentWebView.getUrl(), currentWebView.getTitle(), currentWebView.getFavoriteOrDefaultIcon());
598
599             // Display the create bookmark dialog.
600             createBookmarkDialog.show(getSupportFragmentManager(), getString(R.string.create_bookmark));
601         });
602
603         // Search for the string on the page whenever a character changes in the `findOnPageEditText`.
604         findOnPageEditText.addTextChangedListener(new TextWatcher() {
605             @Override
606             public void beforeTextChanged(CharSequence s, int start, int count, int after) {
607                 // Do nothing.
608             }
609
610             @Override
611             public void onTextChanged(CharSequence s, int start, int before, int count) {
612                 // Do nothing.
613             }
614
615             @Override
616             public void afterTextChanged(Editable s) {
617                 // Search for the text in the WebView if it is not null.  Sometimes on resume after a period of non-use the WebView will be null.
618                 if (currentWebView != null) {
619                     currentWebView.findAllAsync(findOnPageEditText.getText().toString());
620                 }
621             }
622         });
623
624         // Set the `check mark` button for the `findOnPageEditText` keyboard to close the soft keyboard.
625         findOnPageEditText.setOnKeyListener((v, keyCode, event) -> {
626             if ((event.getAction() == KeyEvent.ACTION_DOWN) && (keyCode == KeyEvent.KEYCODE_ENTER)) {  // The `enter` key was pressed.
627                 // Hide the soft keyboard.
628                 inputMethodManager.hideSoftInputFromWindow(currentWebView.getWindowToken(), 0);
629
630                 // Consume the event.
631                 return true;
632             } else {  // A different key was pressed.
633                 // Do not consume the event.
634                 return false;
635             }
636         });
637
638         // Implement swipe to refresh.
639         swipeRefreshLayout.setOnRefreshListener(() -> currentWebView.reload());
640
641         // Store the default progress view offsets for use later in `initializeWebView()`.
642         defaultProgressViewStartOffset = swipeRefreshLayout.getProgressViewStartOffset();
643         defaultProgressViewEndOffset = swipeRefreshLayout.getProgressViewEndOffset();
644
645         // Set the swipe to refresh color according to the theme.
646         if (darkTheme) {
647             swipeRefreshLayout.setColorSchemeResources(R.color.blue_800);
648             swipeRefreshLayout.setProgressBackgroundColorSchemeResource(R.color.gray_850);
649         } else {
650             swipeRefreshLayout.setColorSchemeResources(R.color.blue_500);
651         }
652
653         // `DrawerTitle` identifies the `DrawerLayouts` in accessibility mode.
654         drawerLayout.setDrawerTitle(GravityCompat.START, getString(R.string.navigation_drawer));
655         drawerLayout.setDrawerTitle(GravityCompat.END, getString(R.string.bookmarks));
656
657         // Initialize the bookmarks database helper.  The `0` specifies a database version, but that is ignored and set instead using a constant in `BookmarksDatabaseHelper`.
658         bookmarksDatabaseHelper = new BookmarksDatabaseHelper(this, null, null, 0);
659
660         // Initialize `currentBookmarksFolder`.  `""` is the home folder in the database.
661         currentBookmarksFolder = "";
662
663         // Load the home folder, which is `""` in the database.
664         loadBookmarksFolder();
665
666         bookmarksListView.setOnItemClickListener((parent, view, position, id) -> {
667             // Convert the id from long to int to match the format of the bookmarks database.
668             int databaseID = (int) id;
669
670             // Get the bookmark cursor for this ID and move it to the first row.
671             Cursor bookmarkCursor = bookmarksDatabaseHelper.getBookmark(databaseID);
672             bookmarkCursor.moveToFirst();
673
674             // Act upon the bookmark according to the type.
675             if (bookmarkCursor.getInt(bookmarkCursor.getColumnIndex(BookmarksDatabaseHelper.IS_FOLDER)) == 1) {  // The selected bookmark is a folder.
676                 // Store the new folder name in `currentBookmarksFolder`.
677                 currentBookmarksFolder = bookmarkCursor.getString(bookmarkCursor.getColumnIndex(BookmarksDatabaseHelper.BOOKMARK_NAME));
678
679                 // Load the new folder.
680                 loadBookmarksFolder();
681             } else {  // The selected bookmark is not a folder.
682                 // Load the bookmark URL.
683                 loadUrl(bookmarkCursor.getString(bookmarkCursor.getColumnIndex(BookmarksDatabaseHelper.BOOKMARK_URL)));
684
685                 // Close the bookmarks drawer.
686                 drawerLayout.closeDrawer(GravityCompat.END);
687             }
688
689             // Close the `Cursor`.
690             bookmarkCursor.close();
691         });
692
693         bookmarksListView.setOnItemLongClickListener((parent, view, position, id) -> {
694             // Convert the database ID from `long` to `int`.
695             int databaseId = (int) id;
696
697             // Find out if the selected bookmark is a folder.
698             boolean isFolder = bookmarksDatabaseHelper.isFolder(databaseId);
699
700             if (isFolder) {
701                 // Save the current folder name, which is used in `onSaveEditBookmarkFolder()`.
702                 oldFolderNameString = bookmarksCursor.getString(bookmarksCursor.getColumnIndex(BookmarksDatabaseHelper.BOOKMARK_NAME));
703
704                 // Show the edit bookmark folder `AlertDialog` and name the instance `@string/edit_folder`.
705                 DialogFragment editBookmarkFolderDialog = EditBookmarkFolderDialog.folderDatabaseId(databaseId, currentWebView.getFavoriteOrDefaultIcon());
706                 editBookmarkFolderDialog.show(getSupportFragmentManager(), getString(R.string.edit_folder));
707             } else {
708                 // Show the edit bookmark `AlertDialog` and name the instance `@string/edit_bookmark`.
709                 DialogFragment editBookmarkDialog = EditBookmarkDialog.bookmarkDatabaseId(databaseId, currentWebView.getFavoriteOrDefaultIcon());
710                 editBookmarkDialog.show(getSupportFragmentManager(), getString(R.string.edit_bookmark));
711             }
712
713             // Consume the event.
714             return true;
715         });
716
717         // Get the status bar pixel size.
718         int statusBarResourceId = getResources().getIdentifier("status_bar_height", "dimen", "android");
719         int statusBarPixelSize = getResources().getDimensionPixelSize(statusBarResourceId);
720
721         // Get the resource density.
722         float screenDensity = getResources().getDisplayMetrics().density;
723
724         // Calculate the drawer header padding.  This is used to move the text in the drawer headers below any cutouts.
725         drawerHeaderPaddingLeftAndRight = (int) (15 * screenDensity);
726         drawerHeaderPaddingTop = statusBarPixelSize + (int) (4 * screenDensity);
727         drawerHeaderPaddingBottom = (int) (8 * screenDensity);
728
729         // The drawer listener is used to update the navigation menu.`
730         drawerLayout.addDrawerListener(new DrawerLayout.DrawerListener() {
731             @Override
732             public void onDrawerSlide(@NonNull View drawerView, float slideOffset) {
733             }
734
735             @Override
736             public void onDrawerOpened(@NonNull View drawerView) {
737             }
738
739             @Override
740             public void onDrawerClosed(@NonNull View drawerView) {
741             }
742
743             @Override
744             public void onDrawerStateChanged(int newState) {
745                 if ((newState == DrawerLayout.STATE_SETTLING) || (newState == DrawerLayout.STATE_DRAGGING)) {  // A drawer is opening or closing.
746                     // Get handles for the drawer headers.
747                     TextView navigationHeaderTextView = findViewById(R.id.navigationText);
748                     TextView bookmarksHeaderTextView = findViewById(R.id.bookmarks_title_textview);
749
750                     // Apply the navigation header paddings if the view is not null (sometimes it is null if another activity has already started).  This moves the text in the header below any cutouts.
751                     if (navigationHeaderTextView != null) {
752                         navigationHeaderTextView.setPadding(drawerHeaderPaddingLeftAndRight, drawerHeaderPaddingTop, drawerHeaderPaddingLeftAndRight, drawerHeaderPaddingBottom);
753                     }
754
755                     // Apply the bookmarks header paddings if the view is not null (sometimes it is null if another activity has already started).  This moves the text in the header below any cutouts.
756                     if (bookmarksHeaderTextView != null) {
757                         bookmarksHeaderTextView.setPadding(drawerHeaderPaddingLeftAndRight, drawerHeaderPaddingTop, drawerHeaderPaddingLeftAndRight, drawerHeaderPaddingBottom);
758                     }
759
760                     // Update the navigation menu items.
761                     navigationBackMenuItem.setEnabled(currentWebView.canGoBack());
762                     navigationForwardMenuItem.setEnabled(currentWebView.canGoForward());
763                     navigationHistoryMenuItem.setEnabled((currentWebView.canGoBack() || currentWebView.canGoForward()));
764                     navigationRequestsMenuItem.setTitle(getString(R.string.requests) + " - " + currentWebView.getRequestsCount(NestedScrollWebView.BLOCKED_REQUESTS));
765
766                     // Hide the keyboard (if displayed).
767                     inputMethodManager.hideSoftInputFromWindow(currentWebView.getWindowToken(), 0);
768
769                     // Clear the focus from from the URL text box and the WebView.  This removes any text selection markers and context menus, which otherwise draw above the open drawers.
770                     urlEditText.clearFocus();
771                     currentWebView.clearFocus();
772                 }
773             }
774         });
775
776         // Create the hamburger icon at the start of the AppBar.
777         actionBarDrawerToggle = new ActionBarDrawerToggle(this, drawerLayout, toolbar, R.string.open_navigation_drawer, R.string.close_navigation_drawer);
778
779         // Replace the header that `WebView` creates for `X-Requested-With` with a null value.  The default value is the application ID (com.stoutner.privacybrowser.standard).
780         customHeaders.put("X-Requested-With", "");
781
782         // Initialize the default preference values the first time the program is run.  `false` keeps this command from resetting any current preferences back to default.
783         PreferenceManager.setDefaultValues(this, R.xml.preferences, false);
784
785         // Inflate a bare WebView to get the default user agent.  It is not used to render content on the screen.
786         @SuppressLint("InflateParams") View webViewLayout = getLayoutInflater().inflate(R.layout.bare_webview, null, false);
787
788         // Get a handle for the WebView.
789         WebView bareWebView = webViewLayout.findViewById(R.id.bare_webview);
790
791         // Store the default user agent.
792         webViewDefaultUserAgent = bareWebView.getSettings().getUserAgentString();
793
794         // Destroy the bare WebView.
795         bareWebView.destroy();
796
797         // Populate the blocklists.
798         new PopulateBlocklists(this, this).execute();
799     }
800
801     @Override
802     protected void onNewIntent(Intent intent) {
803         // Get the information from the intent.
804         String intentAction = intent.getAction();
805         Uri intentUriData = intent.getData();
806
807         // Determine if this is a web search.
808         boolean isWebSearch = ((intentAction != null) && intentAction.equals(Intent.ACTION_WEB_SEARCH));
809
810         // Only process the URI if it contains data or it is a web search.  If the user pressed the desktop icon after the app was already running the URI will be null.
811         if (intentUriData != null || isWebSearch) {
812             // Get the shared preferences.
813             SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(this);
814
815             // Create a URL string.
816             String url;
817
818             // If the intent action is a web search, perform the search.
819             if (isWebSearch) {
820                 // Create an encoded URL string.
821                 String encodedUrlString;
822
823                 // Sanitize the search input and convert it to a search.
824                 try {
825                     encodedUrlString = URLEncoder.encode(intent.getStringExtra(SearchManager.QUERY), "UTF-8");
826                 } catch (UnsupportedEncodingException exception) {
827                     encodedUrlString = "";
828                 }
829
830                 // Add the base search URL.
831                 url = searchURL + encodedUrlString;
832             } else {  // The intent should contain a URL.
833                 // Set the intent data as the URL.
834                 url = intentUriData.toString();
835             }
836
837             // Add a new tab if specified in the preferences.
838             if (sharedPreferences.getBoolean("open_intents_in_new_tab", true)) {  // Load the URL in a new tab.
839                 // Set the loading new intent flag.
840                 loadingNewIntent = true;
841
842                 // Add a new tab.
843                 addNewTab(url);
844             } else {  // Load the URL in the current tab.
845                 // Make it so.
846                 loadUrl(url);
847             }
848
849             // Get a handle for the drawer layout.
850             DrawerLayout drawerLayout = findViewById(R.id.drawerlayout);
851
852             // Close the navigation drawer if it is open.
853             if (drawerLayout.isDrawerVisible(GravityCompat.START)) {
854                 drawerLayout.closeDrawer(GravityCompat.START);
855             }
856
857             // Close the bookmarks drawer if it is open.
858             if (drawerLayout.isDrawerVisible(GravityCompat.END)) {
859                 drawerLayout.closeDrawer(GravityCompat.END);
860             }
861         }
862     }
863
864     @Override
865     public void onRestart() {
866         // Run the default commands.
867         super.onRestart();
868
869         // Make sure Orbot is running if Privacy Browser is proxying through Orbot.
870         if (proxyThroughOrbot) {
871             // Request Orbot to start.  If Orbot is already running no hard will be caused by this request.
872             Intent orbotIntent = new Intent("org.torproject.android.intent.action.START");
873
874             // Send the intent to the Orbot package.
875             orbotIntent.setPackage("org.torproject.android");
876
877             // Make it so.
878             sendBroadcast(orbotIntent);
879         }
880
881         // Apply the app settings if returning from the Settings activity.
882         if (reapplyAppSettingsOnRestart) {
883             // Reset the reapply app settings on restart tracker.
884             reapplyAppSettingsOnRestart = false;
885
886             // Apply the app settings.
887             applyAppSettings();
888         }
889
890         // Apply the domain settings if returning from the settings or domains activity.
891         if (reapplyDomainSettingsOnRestart) {
892             // Reset the reapply domain settings on restart tracker.
893             reapplyDomainSettingsOnRestart = false;
894
895             // Reapply the domain settings for each tab.
896             for (int i = 0; i < webViewPagerAdapter.getCount(); i++) {
897                 // Get the WebView tab fragment.
898                 WebViewTabFragment webViewTabFragment = webViewPagerAdapter.getPageFragment(i);
899
900                 // Get the fragment view.
901                 View fragmentView = webViewTabFragment.getView();
902
903                 // Only reload the WebViews if they exist.
904                 if (fragmentView != null) {
905                     // Get the nested scroll WebView from the tab fragment.
906                     NestedScrollWebView nestedScrollWebView = fragmentView.findViewById(R.id.nestedscroll_webview);
907
908                     // Reset the current domain name so the domain settings will be reapplied.
909                     nestedScrollWebView.resetCurrentDomainName();
910
911                     // Reapply the domain settings if the URL is not null, which can happen if an empty tab is active when returning from settings.
912                     if (nestedScrollWebView.getUrl() != null) {
913                         applyDomainSettings(nestedScrollWebView, nestedScrollWebView.getUrl(), false, true);
914                     }
915                 }
916             }
917         }
918
919         // Load the URL on restart (used when loading a bookmark).
920         if (loadUrlOnRestart) {
921             // Load the specified URL.
922             loadUrl(urlToLoadOnRestart);
923
924             // Reset the load on restart tracker.
925             loadUrlOnRestart = false;
926         }
927
928         // Update the bookmarks drawer if returning from the Bookmarks activity.
929         if (restartFromBookmarksActivity) {
930             // Get a handle for the drawer layout.
931             DrawerLayout drawerLayout = findViewById(R.id.drawerlayout);
932
933             // Close the bookmarks drawer.
934             drawerLayout.closeDrawer(GravityCompat.END);
935
936             // Reload the bookmarks drawer.
937             loadBookmarksFolder();
938
939             // Reset `restartFromBookmarksActivity`.
940             restartFromBookmarksActivity = false;
941         }
942
943         // Update the privacy icon.  `true` runs `invalidateOptionsMenu` as the last step.  This can be important if the screen was rotated.
944         updatePrivacyIcons(true);
945     }
946
947     // `onResume()` runs after `onStart()`, which runs after `onCreate()` and `onRestart()`.
948     @Override
949     public void onResume() {
950         // Run the default commands.
951         super.onResume();
952
953         for (int i = 0; i < webViewPagerAdapter.getCount(); i++) {
954             // Get the WebView tab fragment.
955             WebViewTabFragment webViewTabFragment = webViewPagerAdapter.getPageFragment(i);
956
957             // Get the fragment view.
958             View fragmentView = webViewTabFragment.getView();
959
960             // Only resume the WebViews if they exist (they won't when the app is first created).
961             if (fragmentView != null) {
962                 // Get the nested scroll WebView from the tab fragment.
963                 NestedScrollWebView nestedScrollWebView = fragmentView.findViewById(R.id.nestedscroll_webview);
964
965                 // Resume the nested scroll WebView JavaScript timers.
966                 nestedScrollWebView.resumeTimers();
967
968                 // Resume the nested scroll WebView.
969                 nestedScrollWebView.onResume();
970             }
971         }
972
973         // Display a message to the user if waiting for Orbot.
974         if (waitingForOrbot && !orbotStatus.equals("ON")) {
975             // Disable the wide view port so that the waiting for Orbot text is displayed correctly.
976             currentWebView.getSettings().setUseWideViewPort(false);
977
978             // Load a waiting page.  `null` specifies no encoding, which defaults to ASCII.
979             currentWebView.loadData("<html><body><br/><center><h1>" + getString(R.string.waiting_for_orbot) + "</h1></center></body></html>", "text/html", null);
980         }
981
982         if (displayingFullScreenVideo || inFullScreenBrowsingMode) {
983             // Get a handle for the root frame layouts.
984             FrameLayout rootFrameLayout = findViewById(R.id.root_framelayout);
985
986             // Remove the translucent status flag.  This is necessary so the root frame layout can fill the entire screen.
987             getWindow().clearFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS);
988
989             /* Hide the system bars.
990              * SYSTEM_UI_FLAG_FULLSCREEN hides the status bar at the top of the screen.
991              * SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN makes the root frame layout fill the area that is normally reserved for the status bar.
992              * SYSTEM_UI_FLAG_HIDE_NAVIGATION hides the navigation bar on the bottom or right of the screen.
993              * SYSTEM_UI_FLAG_IMMERSIVE_STICKY makes the status and navigation bars translucent and automatically re-hides them after they are shown.
994              */
995             rootFrameLayout.setSystemUiVisibility(View.SYSTEM_UI_FLAG_FULLSCREEN | View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN | View.SYSTEM_UI_FLAG_HIDE_NAVIGATION |
996                     View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY);
997         } else if (BuildConfig.FLAVOR.contentEquals("free")) {  // Resume the adView for the free flavor.
998             // Resume the ad.
999             AdHelper.resumeAd(findViewById(R.id.adview));
1000         }
1001     }
1002
1003     @Override
1004     public void onPause() {
1005         // Run the default commands.
1006         super.onPause();
1007
1008         for (int i = 0; i < webViewPagerAdapter.getCount(); i++) {
1009             // Get the WebView tab fragment.
1010             WebViewTabFragment webViewTabFragment = webViewPagerAdapter.getPageFragment(i);
1011
1012             // Get the fragment view.
1013             View fragmentView = webViewTabFragment.getView();
1014
1015             // Only pause the WebViews if they exist (they won't when the app is first created).
1016             if (fragmentView != null) {
1017                 // Get the nested scroll WebView from the tab fragment.
1018                 NestedScrollWebView nestedScrollWebView = fragmentView.findViewById(R.id.nestedscroll_webview);
1019
1020                 // Pause the nested scroll WebView.
1021                 nestedScrollWebView.onPause();
1022
1023                 // Pause the nested scroll WebView JavaScript timers.
1024                 nestedScrollWebView.pauseTimers();
1025             }
1026         }
1027
1028         // Pause the ad or it will continue to consume resources in the background on the free flavor.
1029         if (BuildConfig.FLAVOR.contentEquals("free")) {
1030             // Pause the ad.
1031             AdHelper.pauseAd(findViewById(R.id.adview));
1032         }
1033     }
1034
1035     @Override
1036     public void onDestroy() {
1037         // Unregister the Orbot status broadcast receiver.
1038         this.unregisterReceiver(orbotStatusBroadcastReceiver);
1039
1040         // Close the bookmarks cursor and database.
1041         bookmarksCursor.close();
1042         bookmarksDatabaseHelper.close();
1043
1044         // Run the default commands.
1045         super.onDestroy();
1046     }
1047
1048     @Override
1049     public boolean onCreateOptionsMenu(Menu menu) {
1050         // Inflate the menu.  This adds items to the action bar if it is present.
1051         getMenuInflater().inflate(R.menu.webview_options_menu, menu);
1052
1053         // Store a handle for the options menu so it can be used by `onOptionsItemSelected()` and `updatePrivacyIcons()`.
1054         optionsMenu = menu;
1055
1056         // Set the initial status of the privacy icons.  `false` does not call `invalidateOptionsMenu` as the last step.
1057         updatePrivacyIcons(false);
1058
1059         // Get handles for the menu items.
1060         MenuItem toggleFirstPartyCookiesMenuItem = menu.findItem(R.id.toggle_first_party_cookies);
1061         MenuItem toggleThirdPartyCookiesMenuItem = menu.findItem(R.id.toggle_third_party_cookies);
1062         MenuItem toggleDomStorageMenuItem = menu.findItem(R.id.toggle_dom_storage);
1063         MenuItem toggleSaveFormDataMenuItem = menu.findItem(R.id.toggle_save_form_data);  // Form data can be removed once the minimum API >= 26.
1064         MenuItem clearFormDataMenuItem = menu.findItem(R.id.clear_form_data);  // Form data can be removed once the minimum API >= 26.
1065         MenuItem refreshMenuItem = menu.findItem(R.id.refresh);
1066         MenuItem adConsentMenuItem = menu.findItem(R.id.ad_consent);
1067
1068         // Only display third-party cookies if API >= 21
1069         toggleThirdPartyCookiesMenuItem.setVisible(Build.VERSION.SDK_INT >= 21);
1070
1071         // Only display the form data menu items if the API < 26.
1072         toggleSaveFormDataMenuItem.setVisible(Build.VERSION.SDK_INT < 26);
1073         clearFormDataMenuItem.setVisible(Build.VERSION.SDK_INT < 26);
1074
1075         // Disable the clear form data menu item if the API >= 26 so that the status of the main Clear Data is calculated correctly.
1076         clearFormDataMenuItem.setEnabled(Build.VERSION.SDK_INT < 26);
1077
1078         // Only show Ad Consent if this is the free flavor.
1079         adConsentMenuItem.setVisible(BuildConfig.FLAVOR.contentEquals("free"));
1080
1081         // Get the shared preferences.
1082         SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(this);
1083
1084         // Get the dark theme and app bar preferences..
1085         boolean displayAdditionalAppBarIcons = sharedPreferences.getBoolean("display_additional_app_bar_icons", false);
1086         boolean darkTheme = sharedPreferences.getBoolean("dark_theme", false);
1087
1088         // Set the status of the additional app bar icons.  Setting the refresh menu item to `SHOW_AS_ACTION_ALWAYS` makes it appear even on small devices like phones.
1089         if (displayAdditionalAppBarIcons) {
1090             toggleFirstPartyCookiesMenuItem.setShowAsAction(MenuItem.SHOW_AS_ACTION_IF_ROOM);
1091             toggleDomStorageMenuItem.setShowAsAction(MenuItem.SHOW_AS_ACTION_IF_ROOM);
1092             refreshMenuItem.setShowAsAction(MenuItem.SHOW_AS_ACTION_ALWAYS);
1093         } else { //Do not display the additional icons.
1094             toggleFirstPartyCookiesMenuItem.setShowAsAction(MenuItem.SHOW_AS_ACTION_NEVER);
1095             toggleDomStorageMenuItem.setShowAsAction(MenuItem.SHOW_AS_ACTION_NEVER);
1096             refreshMenuItem.setShowAsAction(MenuItem.SHOW_AS_ACTION_NEVER);
1097         }
1098
1099         // Replace Refresh with Stop if a URL is already loading.
1100         if (currentWebView != null && currentWebView.getProgress() != 100) {
1101             // Set the title.
1102             refreshMenuItem.setTitle(R.string.stop);
1103
1104             // If the icon is displayed in the AppBar, set it according to the theme.
1105             if (displayAdditionalAppBarIcons) {
1106                 if (darkTheme) {
1107                     refreshMenuItem.setIcon(R.drawable.close_dark);
1108                 } else {
1109                     refreshMenuItem.setIcon(R.drawable.close_light);
1110                 }
1111             }
1112         }
1113
1114         return true;
1115     }
1116
1117     @Override
1118     public boolean onPrepareOptionsMenu(Menu menu) {
1119         // Get handles for the menu items.
1120         MenuItem addOrEditDomain = menu.findItem(R.id.add_or_edit_domain);
1121         MenuItem firstPartyCookiesMenuItem = menu.findItem(R.id.toggle_first_party_cookies);
1122         MenuItem thirdPartyCookiesMenuItem = menu.findItem(R.id.toggle_third_party_cookies);
1123         MenuItem domStorageMenuItem = menu.findItem(R.id.toggle_dom_storage);
1124         MenuItem saveFormDataMenuItem = menu.findItem(R.id.toggle_save_form_data);  // Form data can be removed once the minimum API >= 26.
1125         MenuItem clearDataMenuItem = menu.findItem(R.id.clear_data);
1126         MenuItem clearCookiesMenuItem = menu.findItem(R.id.clear_cookies);
1127         MenuItem clearDOMStorageMenuItem = menu.findItem(R.id.clear_dom_storage);
1128         MenuItem clearFormDataMenuItem = menu.findItem(R.id.clear_form_data);  // Form data can be removed once the minimum API >= 26.
1129         MenuItem blocklistsMenuItem = menu.findItem(R.id.blocklists);
1130         MenuItem easyListMenuItem = menu.findItem(R.id.easylist);
1131         MenuItem easyPrivacyMenuItem = menu.findItem(R.id.easyprivacy);
1132         MenuItem fanboysAnnoyanceListMenuItem = menu.findItem(R.id.fanboys_annoyance_list);
1133         MenuItem fanboysSocialBlockingListMenuItem = menu.findItem(R.id.fanboys_social_blocking_list);
1134         MenuItem ultraPrivacyMenuItem = menu.findItem(R.id.ultraprivacy);
1135         MenuItem blockAllThirdPartyRequestsMenuItem = menu.findItem(R.id.block_all_third_party_requests);
1136         MenuItem fontSizeMenuItem = menu.findItem(R.id.font_size);
1137         MenuItem swipeToRefreshMenuItem = menu.findItem(R.id.swipe_to_refresh);
1138         MenuItem wideViewportMenuItem = menu.findItem(R.id.wide_viewport);
1139         MenuItem displayImagesMenuItem = menu.findItem(R.id.display_images);
1140         MenuItem nightModeMenuItem = menu.findItem(R.id.night_mode);
1141         MenuItem proxyThroughOrbotMenuItem = menu.findItem(R.id.proxy_through_orbot);
1142
1143         // Get a handle for the cookie manager.
1144         CookieManager cookieManager = CookieManager.getInstance();
1145
1146         // Initialize the current user agent string and the font size.
1147         String currentUserAgent = getString(R.string.user_agent_privacy_browser);
1148         int fontSize = 100;
1149
1150         // Set items that require the current web view to be populated.  It will be null when the program is first opened, as `onPrepareOptionsMenu()` is called before the first WebView is initialized.
1151         if (currentWebView != null) {
1152             // Set the add or edit domain text.
1153             if (currentWebView.getDomainSettingsApplied()) {
1154                 addOrEditDomain.setTitle(R.string.edit_domain_settings);
1155             } else {
1156                 addOrEditDomain.setTitle(R.string.add_domain_settings);
1157             }
1158
1159             // Get the current user agent from the WebView.
1160             currentUserAgent = currentWebView.getSettings().getUserAgentString();
1161
1162             // Get the current font size from the
1163             fontSize = currentWebView.getSettings().getTextZoom();
1164
1165             // Set the status of the menu item checkboxes.
1166             domStorageMenuItem.setChecked(currentWebView.getSettings().getDomStorageEnabled());
1167             saveFormDataMenuItem.setChecked(currentWebView.getSettings().getSaveFormData());  // Form data can be removed once the minimum API >= 26.
1168             easyListMenuItem.setChecked(currentWebView.isBlocklistEnabled(NestedScrollWebView.EASY_LIST));
1169             easyPrivacyMenuItem.setChecked(currentWebView.isBlocklistEnabled(NestedScrollWebView.EASY_PRIVACY));
1170             fanboysAnnoyanceListMenuItem.setChecked(currentWebView.isBlocklistEnabled(NestedScrollWebView.FANBOYS_ANNOYANCE_LIST));
1171             fanboysSocialBlockingListMenuItem.setChecked(currentWebView.isBlocklistEnabled(NestedScrollWebView.FANBOYS_SOCIAL_BLOCKING_LIST));
1172             ultraPrivacyMenuItem.setChecked(currentWebView.isBlocklistEnabled(NestedScrollWebView.ULTRA_PRIVACY));
1173             blockAllThirdPartyRequestsMenuItem.setChecked(currentWebView.isBlocklistEnabled(NestedScrollWebView.THIRD_PARTY_REQUESTS));
1174             swipeToRefreshMenuItem.setChecked(currentWebView.getSwipeToRefresh());
1175             wideViewportMenuItem.setChecked(currentWebView.getSettings().getUseWideViewPort());
1176             displayImagesMenuItem.setChecked(currentWebView.getSettings().getLoadsImagesAutomatically());
1177             nightModeMenuItem.setChecked(currentWebView.getNightMode());
1178
1179             // Initialize the display names for the blocklists with the number of blocked requests.
1180             blocklistsMenuItem.setTitle(getString(R.string.blocklists) + " - " + currentWebView.getRequestsCount(NestedScrollWebView.BLOCKED_REQUESTS));
1181             easyListMenuItem.setTitle(currentWebView.getRequestsCount(NestedScrollWebView.EASY_LIST) + " - " + getString(R.string.easylist));
1182             easyPrivacyMenuItem.setTitle(currentWebView.getRequestsCount(NestedScrollWebView.EASY_PRIVACY) + " - " + getString(R.string.easyprivacy));
1183             fanboysAnnoyanceListMenuItem.setTitle(currentWebView.getRequestsCount(NestedScrollWebView.FANBOYS_ANNOYANCE_LIST) + " - " + getString(R.string.fanboys_annoyance_list));
1184             fanboysSocialBlockingListMenuItem.setTitle(currentWebView.getRequestsCount(NestedScrollWebView.FANBOYS_SOCIAL_BLOCKING_LIST) + " - " + getString(R.string.fanboys_social_blocking_list));
1185             ultraPrivacyMenuItem.setTitle(currentWebView.getRequestsCount(NestedScrollWebView.ULTRA_PRIVACY) + " - " + getString(R.string.ultraprivacy));
1186             blockAllThirdPartyRequestsMenuItem.setTitle(currentWebView.getRequestsCount(NestedScrollWebView.THIRD_PARTY_REQUESTS) + " - " + getString(R.string.block_all_third_party_requests));
1187
1188             // Only modify third-party cookies if the API >= 21.
1189             if (Build.VERSION.SDK_INT >= 21) {
1190                 // Set the status of the third-party cookies checkbox.
1191                 thirdPartyCookiesMenuItem.setChecked(cookieManager.acceptThirdPartyCookies(currentWebView));
1192
1193                 // Enable third-party cookies if first-party cookies are enabled.
1194                 thirdPartyCookiesMenuItem.setEnabled(cookieManager.acceptCookie());
1195             }
1196
1197             // Enable DOM Storage if JavaScript is enabled.
1198             domStorageMenuItem.setEnabled(currentWebView.getSettings().getJavaScriptEnabled());
1199         }
1200
1201         // Set the status of the menu item checkboxes.
1202         firstPartyCookiesMenuItem.setChecked(cookieManager.acceptCookie());
1203         proxyThroughOrbotMenuItem.setChecked(proxyThroughOrbot);
1204
1205         // Enable Clear Cookies if there are any.
1206         clearCookiesMenuItem.setEnabled(cookieManager.hasCookies());
1207
1208         // Get the application's private data directory, which will be something like `/data/user/0/com.stoutner.privacybrowser.standard`, which links to `/data/data/com.stoutner.privacybrowser.standard`.
1209         String privateDataDirectoryString = getApplicationInfo().dataDir;
1210
1211         // Get a count of the number of files in the Local Storage directory.
1212         File localStorageDirectory = new File (privateDataDirectoryString + "/app_webview/Local Storage/");
1213         int localStorageDirectoryNumberOfFiles = 0;
1214         if (localStorageDirectory.exists()) {
1215             localStorageDirectoryNumberOfFiles = localStorageDirectory.list().length;
1216         }
1217
1218         // Get a count of the number of files in the IndexedDB directory.
1219         File indexedDBDirectory = new File (privateDataDirectoryString + "/app_webview/IndexedDB");
1220         int indexedDBDirectoryNumberOfFiles = 0;
1221         if (indexedDBDirectory.exists()) {
1222             indexedDBDirectoryNumberOfFiles = indexedDBDirectory.list().length;
1223         }
1224
1225         // Enable Clear DOM Storage if there is any.
1226         clearDOMStorageMenuItem.setEnabled(localStorageDirectoryNumberOfFiles > 0 || indexedDBDirectoryNumberOfFiles > 0);
1227
1228         // Enable Clear Form Data is there is any.  This can be removed once the minimum API >= 26.
1229         if (Build.VERSION.SDK_INT < 26) {
1230             // Get the WebView database.
1231             WebViewDatabase webViewDatabase = WebViewDatabase.getInstance(this);
1232
1233             // Enable the clear form data menu item if there is anything to clear.
1234             clearFormDataMenuItem.setEnabled(webViewDatabase.hasFormData());
1235         }
1236
1237         // Enable Clear Data if any of the submenu items are enabled.
1238         clearDataMenuItem.setEnabled(clearCookiesMenuItem.isEnabled() || clearDOMStorageMenuItem.isEnabled() || clearFormDataMenuItem.isEnabled());
1239
1240         // Disable Fanboy's Social Blocking List menu item if Fanboy's Annoyance List is checked.
1241         fanboysSocialBlockingListMenuItem.setEnabled(!fanboysAnnoyanceListMenuItem.isChecked());
1242
1243         // Select the current user agent menu item.  A switch statement cannot be used because the user agents are not compile time constants.
1244         if (currentUserAgent.equals(getResources().getStringArray(R.array.user_agent_data)[0])) {  // Privacy Browser.
1245             menu.findItem(R.id.user_agent_privacy_browser).setChecked(true);
1246         } else if (currentUserAgent.equals(webViewDefaultUserAgent)) {  // WebView Default.
1247             menu.findItem(R.id.user_agent_webview_default).setChecked(true);
1248         } else if (currentUserAgent.equals(getResources().getStringArray(R.array.user_agent_data)[2])) {  // Firefox on Android.
1249             menu.findItem(R.id.user_agent_firefox_on_android).setChecked(true);
1250         } else if (currentUserAgent.equals(getResources().getStringArray(R.array.user_agent_data)[3])) {  // Chrome on Android.
1251             menu.findItem(R.id.user_agent_chrome_on_android).setChecked(true);
1252         } else if (currentUserAgent.equals(getResources().getStringArray(R.array.user_agent_data)[4])) {  // Safari on iOS.
1253             menu.findItem(R.id.user_agent_safari_on_ios).setChecked(true);
1254         } else if (currentUserAgent.equals(getResources().getStringArray(R.array.user_agent_data)[5])) {  // Firefox on Linux.
1255             menu.findItem(R.id.user_agent_firefox_on_linux).setChecked(true);
1256         } else if (currentUserAgent.equals(getResources().getStringArray(R.array.user_agent_data)[6])) {  // Chromium on Linux.
1257             menu.findItem(R.id.user_agent_chromium_on_linux).setChecked(true);
1258         } else if (currentUserAgent.equals(getResources().getStringArray(R.array.user_agent_data)[7])) {  // Firefox on Windows.
1259             menu.findItem(R.id.user_agent_firefox_on_windows).setChecked(true);
1260         } else if (currentUserAgent.equals(getResources().getStringArray(R.array.user_agent_data)[8])) {  // Chrome on Windows.
1261             menu.findItem(R.id.user_agent_chrome_on_windows).setChecked(true);
1262         } else if (currentUserAgent.equals(getResources().getStringArray(R.array.user_agent_data)[9])) {  // Edge on Windows.
1263             menu.findItem(R.id.user_agent_edge_on_windows).setChecked(true);
1264         } else if (currentUserAgent.equals(getResources().getStringArray(R.array.user_agent_data)[10])) {  // Internet Explorer on Windows.
1265             menu.findItem(R.id.user_agent_internet_explorer_on_windows).setChecked(true);
1266         } else if (currentUserAgent.equals(getResources().getStringArray(R.array.user_agent_data)[11])) {  // Safari on macOS.
1267             menu.findItem(R.id.user_agent_safari_on_macos).setChecked(true);
1268         } else {  // Custom user agent.
1269             menu.findItem(R.id.user_agent_custom).setChecked(true);
1270         }
1271
1272         // Instantiate the font size title and the selected font size menu item.
1273         String fontSizeTitle;
1274         MenuItem selectedFontSizeMenuItem;
1275
1276         // Prepare the font size title and current size menu item.
1277         switch (fontSize) {
1278             case 25:
1279                 fontSizeTitle = getString(R.string.font_size) + " - " + getString(R.string.twenty_five_percent);
1280                 selectedFontSizeMenuItem = menu.findItem(R.id.font_size_twenty_five_percent);
1281                 break;
1282
1283             case 50:
1284                 fontSizeTitle = getString(R.string.font_size) + " - " + getString(R.string.fifty_percent);
1285                 selectedFontSizeMenuItem = menu.findItem(R.id.font_size_fifty_percent);
1286                 break;
1287
1288             case 75:
1289                 fontSizeTitle = getString(R.string.font_size) + " - " + getString(R.string.seventy_five_percent);
1290                 selectedFontSizeMenuItem = menu.findItem(R.id.font_size_seventy_five_percent);
1291                 break;
1292
1293             case 100:
1294                 fontSizeTitle = getString(R.string.font_size) + " - " + getString(R.string.one_hundred_percent);
1295                 selectedFontSizeMenuItem = menu.findItem(R.id.font_size_one_hundred_percent);
1296                 break;
1297
1298             case 125:
1299                 fontSizeTitle = getString(R.string.font_size) + " - " + getString(R.string.one_hundred_twenty_five_percent);
1300                 selectedFontSizeMenuItem = menu.findItem(R.id.font_size_one_hundred_twenty_five_percent);
1301                 break;
1302
1303             case 150:
1304                 fontSizeTitle = getString(R.string.font_size) + " - " + getString(R.string.one_hundred_fifty_percent);
1305                 selectedFontSizeMenuItem = menu.findItem(R.id.font_size_one_hundred_fifty_percent);
1306                 break;
1307
1308             case 175:
1309                 fontSizeTitle = getString(R.string.font_size) + " - " + getString(R.string.one_hundred_seventy_five_percent);
1310                 selectedFontSizeMenuItem = menu.findItem(R.id.font_size_one_hundred_seventy_five_percent);
1311                 break;
1312
1313             case 200:
1314                 fontSizeTitle = getString(R.string.font_size) + " - " + getString(R.string.two_hundred_percent);
1315                 selectedFontSizeMenuItem = menu.findItem(R.id.font_size_two_hundred_percent);
1316                 break;
1317
1318             default:
1319                 fontSizeTitle = getString(R.string.font_size) + " - " + getString(R.string.one_hundred_percent);
1320                 selectedFontSizeMenuItem = menu.findItem(R.id.font_size_one_hundred_percent);
1321                 break;
1322         }
1323
1324         // Set the font size title and select the current size menu item.
1325         fontSizeMenuItem.setTitle(fontSizeTitle);
1326         selectedFontSizeMenuItem.setChecked(true);
1327
1328         // Run all the other default commands.
1329         super.onPrepareOptionsMenu(menu);
1330
1331         // Display the menu.
1332         return true;
1333     }
1334
1335     @Override
1336     // Remove Android Studio's warning about the dangers of using SetJavaScriptEnabled.
1337     @SuppressLint("SetJavaScriptEnabled")
1338     public boolean onOptionsItemSelected(MenuItem menuItem) {
1339         // Reenter full screen browsing mode if it was interrupted by the options menu.  <https://redmine.stoutner.com/issues/389>
1340         if (inFullScreenBrowsingMode) {
1341             // Remove the translucent status flag.  This is necessary so the root frame layout can fill the entire screen.
1342             getWindow().clearFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS);
1343
1344             FrameLayout rootFrameLayout = findViewById(R.id.root_framelayout);
1345
1346             /* Hide the system bars.
1347              * SYSTEM_UI_FLAG_FULLSCREEN hides the status bar at the top of the screen.
1348              * SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN makes the root frame layout fill the area that is normally reserved for the status bar.
1349              * SYSTEM_UI_FLAG_HIDE_NAVIGATION hides the navigation bar on the bottom or right of the screen.
1350              * SYSTEM_UI_FLAG_IMMERSIVE_STICKY makes the status and navigation bars translucent and automatically re-hides them after they are shown.
1351              */
1352             rootFrameLayout.setSystemUiVisibility(View.SYSTEM_UI_FLAG_FULLSCREEN | View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN | View.SYSTEM_UI_FLAG_HIDE_NAVIGATION |
1353                     View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY);
1354         }
1355
1356         // Get the selected menu item ID.
1357         int menuItemId = menuItem.getItemId();
1358
1359         // Get a handle for the shared preferences.
1360         SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(this);
1361
1362         // Get a handle for the cookie manager.
1363         CookieManager cookieManager = CookieManager.getInstance();
1364
1365         // Run the commands that correlate to the selected menu item.
1366         switch (menuItemId) {
1367             case R.id.toggle_javascript:
1368                 // Toggle the JavaScript status.
1369                 currentWebView.getSettings().setJavaScriptEnabled(!currentWebView.getSettings().getJavaScriptEnabled());
1370
1371                 // Update the privacy icon.  `true` runs `invalidateOptionsMenu` as the last step.
1372                 updatePrivacyIcons(true);
1373
1374                 // Display a `Snackbar`.
1375                 if (currentWebView.getSettings().getJavaScriptEnabled()) {  // JavaScrip is enabled.
1376                     Snackbar.make(findViewById(R.id.webviewpager), R.string.javascript_enabled, Snackbar.LENGTH_SHORT).show();
1377                 } else if (cookieManager.acceptCookie()) {  // JavaScript is disabled, but first-party cookies are enabled.
1378                     Snackbar.make(findViewById(R.id.webviewpager), R.string.javascript_disabled, Snackbar.LENGTH_SHORT).show();
1379                 } else {  // Privacy mode.
1380                     Snackbar.make(findViewById(R.id.webviewpager), R.string.privacy_mode, Snackbar.LENGTH_SHORT).show();
1381                 }
1382
1383                 // Reload the current WebView.
1384                 currentWebView.reload();
1385                 return true;
1386
1387             case R.id.add_or_edit_domain:
1388                 if (currentWebView.getDomainSettingsApplied()) {  // Edit the current domain settings.
1389                     // Reapply the domain settings on returning to `MainWebViewActivity`.
1390                     reapplyDomainSettingsOnRestart = true;
1391
1392                     // Create an intent to launch the domains activity.
1393                     Intent domainsIntent = new Intent(this, DomainsActivity.class);
1394
1395                     // Add the extra information to the intent.
1396                     domainsIntent.putExtra("load_domain", currentWebView.getDomainSettingsDatabaseId());
1397                     domainsIntent.putExtra("close_on_back", true);
1398                     domainsIntent.putExtra("current_url", currentWebView.getUrl());
1399
1400                     // Get the current certificate.
1401                     SslCertificate sslCertificate = currentWebView.getCertificate();
1402
1403                     // Check to see if the SSL certificate is populated.
1404                     if (sslCertificate != null) {
1405                         // Extract the certificate to strings.
1406                         String issuedToCName = sslCertificate.getIssuedTo().getCName();
1407                         String issuedToOName = sslCertificate.getIssuedTo().getOName();
1408                         String issuedToUName = sslCertificate.getIssuedTo().getUName();
1409                         String issuedByCName = sslCertificate.getIssuedBy().getCName();
1410                         String issuedByOName = sslCertificate.getIssuedBy().getOName();
1411                         String issuedByUName = sslCertificate.getIssuedBy().getUName();
1412                         long startDateLong = sslCertificate.getValidNotBeforeDate().getTime();
1413                         long endDateLong = sslCertificate.getValidNotAfterDate().getTime();
1414
1415                         // Add the certificate to the intent.
1416                         domainsIntent.putExtra("ssl_issued_to_cname", issuedToCName);
1417                         domainsIntent.putExtra("ssl_issued_to_oname", issuedToOName);
1418                         domainsIntent.putExtra("ssl_issued_to_uname", issuedToUName);
1419                         domainsIntent.putExtra("ssl_issued_by_cname", issuedByCName);
1420                         domainsIntent.putExtra("ssl_issued_by_oname", issuedByOName);
1421                         domainsIntent.putExtra("ssl_issued_by_uname", issuedByUName);
1422                         domainsIntent.putExtra("ssl_start_date", startDateLong);
1423                         domainsIntent.putExtra("ssl_end_date", endDateLong);
1424                     }
1425
1426                     // Check to see if the current IP addresses have been received.
1427                     if (currentWebView.hasCurrentIpAddresses()) {
1428                         // Add the current IP addresses to the intent.
1429                         domainsIntent.putExtra("current_ip_addresses", currentWebView.getCurrentIpAddresses());
1430                     }
1431
1432                     // Make it so.
1433                     startActivity(domainsIntent);
1434                 } else {  // Add a new domain.
1435                     // Apply the new domain settings on returning to `MainWebViewActivity`.
1436                     reapplyDomainSettingsOnRestart = true;
1437
1438                     // Get the current domain
1439                     Uri currentUri = Uri.parse(currentWebView.getUrl());
1440                     String currentDomain = currentUri.getHost();
1441
1442                     // Initialize the database handler.  The `0` specifies the database version, but that is ignored and set instead using a constant in `DomainsDatabaseHelper`.
1443                     DomainsDatabaseHelper domainsDatabaseHelper = new DomainsDatabaseHelper(this, null, null, 0);
1444
1445                     // Create the domain and store the database ID.
1446                     int newDomainDatabaseId = domainsDatabaseHelper.addDomain(currentDomain);
1447
1448                     // Create an intent to launch the domains activity.
1449                     Intent domainsIntent = new Intent(this, DomainsActivity.class);
1450
1451                     // Add the extra information to the intent.
1452                     domainsIntent.putExtra("load_domain", newDomainDatabaseId);
1453                     domainsIntent.putExtra("close_on_back", true);
1454                     domainsIntent.putExtra("current_url", currentWebView.getUrl());
1455
1456                     // Get the current certificate.
1457                     SslCertificate sslCertificate = currentWebView.getCertificate();
1458
1459                     // Check to see if the SSL certificate is populated.
1460                     if (sslCertificate != null) {
1461                         // Extract the certificate to strings.
1462                         String issuedToCName = sslCertificate.getIssuedTo().getCName();
1463                         String issuedToOName = sslCertificate.getIssuedTo().getOName();
1464                         String issuedToUName = sslCertificate.getIssuedTo().getUName();
1465                         String issuedByCName = sslCertificate.getIssuedBy().getCName();
1466                         String issuedByOName = sslCertificate.getIssuedBy().getOName();
1467                         String issuedByUName = sslCertificate.getIssuedBy().getUName();
1468                         long startDateLong = sslCertificate.getValidNotBeforeDate().getTime();
1469                         long endDateLong = sslCertificate.getValidNotAfterDate().getTime();
1470
1471                         // Add the certificate to the intent.
1472                         domainsIntent.putExtra("ssl_issued_to_cname", issuedToCName);
1473                         domainsIntent.putExtra("ssl_issued_to_oname", issuedToOName);
1474                         domainsIntent.putExtra("ssl_issued_to_uname", issuedToUName);
1475                         domainsIntent.putExtra("ssl_issued_by_cname", issuedByCName);
1476                         domainsIntent.putExtra("ssl_issued_by_oname", issuedByOName);
1477                         domainsIntent.putExtra("ssl_issued_by_uname", issuedByUName);
1478                         domainsIntent.putExtra("ssl_start_date", startDateLong);
1479                         domainsIntent.putExtra("ssl_end_date", endDateLong);
1480                     }
1481
1482                     // Check to see if the current IP addresses have been received.
1483                     if (currentWebView.hasCurrentIpAddresses()) {
1484                         // Add the current IP addresses to the intent.
1485                         domainsIntent.putExtra("current_ip_addresses", currentWebView.getCurrentIpAddresses());
1486                     }
1487
1488                     // Make it so.
1489                     startActivity(domainsIntent);
1490                 }
1491                 return true;
1492
1493             case R.id.toggle_first_party_cookies:
1494                 // Switch the first-party cookie status.
1495                 cookieManager.setAcceptCookie(!cookieManager.acceptCookie());
1496
1497                 // Store the first-party cookie status.
1498                 currentWebView.setAcceptFirstPartyCookies(cookieManager.acceptCookie());
1499
1500                 // Update the menu checkbox.
1501                 menuItem.setChecked(cookieManager.acceptCookie());
1502
1503                 // Update the privacy icon.  `true` runs `invalidateOptionsMenu` as the last step.
1504                 updatePrivacyIcons(true);
1505
1506                 // Display a snackbar.
1507                 if (cookieManager.acceptCookie()) {  // First-party cookies are enabled.
1508                     Snackbar.make(findViewById(R.id.webviewpager), R.string.first_party_cookies_enabled, Snackbar.LENGTH_SHORT).show();
1509                 } else if (currentWebView.getSettings().getJavaScriptEnabled()) {  // JavaScript is still enabled.
1510                     Snackbar.make(findViewById(R.id.webviewpager), R.string.first_party_cookies_disabled, Snackbar.LENGTH_SHORT).show();
1511                 } else {  // Privacy mode.
1512                     Snackbar.make(findViewById(R.id.webviewpager), R.string.privacy_mode, Snackbar.LENGTH_SHORT).show();
1513                 }
1514
1515                 // Reload the current WebView.
1516                 currentWebView.reload();
1517                 return true;
1518
1519             case R.id.toggle_third_party_cookies:
1520                 if (Build.VERSION.SDK_INT >= 21) {
1521                     // Switch the status of thirdPartyCookiesEnabled.
1522                     cookieManager.setAcceptThirdPartyCookies(currentWebView, !cookieManager.acceptThirdPartyCookies(currentWebView));
1523
1524                     // Update the menu checkbox.
1525                     menuItem.setChecked(cookieManager.acceptThirdPartyCookies(currentWebView));
1526
1527                     // Display a snackbar.
1528                     if (cookieManager.acceptThirdPartyCookies(currentWebView)) {
1529                         Snackbar.make(findViewById(R.id.webviewpager), R.string.third_party_cookies_enabled, Snackbar.LENGTH_SHORT).show();
1530                     } else {
1531                         Snackbar.make(findViewById(R.id.webviewpager), R.string.third_party_cookies_disabled, Snackbar.LENGTH_SHORT).show();
1532                     }
1533
1534                     // Reload the current WebView.
1535                     currentWebView.reload();
1536                 } // Else do nothing because SDK < 21.
1537                 return true;
1538
1539             case R.id.toggle_dom_storage:
1540                 // Toggle the status of domStorageEnabled.
1541                 currentWebView.getSettings().setDomStorageEnabled(!currentWebView.getSettings().getDomStorageEnabled());
1542
1543                 // Update the menu checkbox.
1544                 menuItem.setChecked(currentWebView.getSettings().getDomStorageEnabled());
1545
1546                 // Update the privacy icon.  `true` refreshes the app bar icons.
1547                 updatePrivacyIcons(true);
1548
1549                 // Display a snackbar.
1550                 if (currentWebView.getSettings().getDomStorageEnabled()) {
1551                     Snackbar.make(findViewById(R.id.webviewpager), R.string.dom_storage_enabled, Snackbar.LENGTH_SHORT).show();
1552                 } else {
1553                     Snackbar.make(findViewById(R.id.webviewpager), R.string.dom_storage_disabled, Snackbar.LENGTH_SHORT).show();
1554                 }
1555
1556                 // Reload the current WebView.
1557                 currentWebView.reload();
1558                 return true;
1559
1560             // Form data can be removed once the minimum API >= 26.
1561             case R.id.toggle_save_form_data:
1562                 // Switch the status of saveFormDataEnabled.
1563                 currentWebView.getSettings().setSaveFormData(!currentWebView.getSettings().getSaveFormData());
1564
1565                 // Update the menu checkbox.
1566                 menuItem.setChecked(currentWebView.getSettings().getSaveFormData());
1567
1568                 // Display a snackbar.
1569                 if (currentWebView.getSettings().getSaveFormData()) {
1570                     Snackbar.make(findViewById(R.id.webviewpager), R.string.form_data_enabled, Snackbar.LENGTH_SHORT).show();
1571                 } else {
1572                     Snackbar.make(findViewById(R.id.webviewpager), R.string.form_data_disabled, Snackbar.LENGTH_SHORT).show();
1573                 }
1574
1575                 // Update the privacy icon.  `true` runs `invalidateOptionsMenu` as the last step.
1576                 updatePrivacyIcons(true);
1577
1578                 // Reload the current WebView.
1579                 currentWebView.reload();
1580                 return true;
1581
1582             case R.id.clear_cookies:
1583                 Snackbar.make(findViewById(R.id.webviewpager), R.string.cookies_deleted, Snackbar.LENGTH_LONG)
1584                         .setAction(R.string.undo, v -> {
1585                             // Do nothing because everything will be handled by `onDismissed()` below.
1586                         })
1587                         .addCallback(new Snackbar.Callback() {
1588                             @SuppressLint("SwitchIntDef")  // Ignore the lint warning about not handling the other possible events as they are covered by `default:`.
1589                             @Override
1590                             public void onDismissed(Snackbar snackbar, int event) {
1591                                 if (event != Snackbar.Callback.DISMISS_EVENT_ACTION) {  // The snackbar was dismissed without the undo button being pushed.
1592                                     // Delete the cookies, which command varies by SDK.
1593                                     if (Build.VERSION.SDK_INT < 21) {
1594                                         cookieManager.removeAllCookie();
1595                                     } else {
1596                                         cookieManager.removeAllCookies(null);
1597                                     }
1598                                 }
1599                             }
1600                         })
1601                         .show();
1602                 return true;
1603
1604             case R.id.clear_dom_storage:
1605                 Snackbar.make(findViewById(R.id.webviewpager), R.string.dom_storage_deleted, Snackbar.LENGTH_LONG)
1606                         .setAction(R.string.undo, v -> {
1607                             // Do nothing because everything will be handled by `onDismissed()` below.
1608                         })
1609                         .addCallback(new Snackbar.Callback() {
1610                             @SuppressLint("SwitchIntDef")  // Ignore the lint warning about not handling the other possible events as they are covered by `default:`.
1611                             @Override
1612                             public void onDismissed(Snackbar snackbar, int event) {
1613                                 if (event != Snackbar.Callback.DISMISS_EVENT_ACTION) {  // The snackbar was dismissed without the undo button being pushed.
1614                                     // Delete the DOM Storage.
1615                                     WebStorage webStorage = WebStorage.getInstance();
1616                                     webStorage.deleteAllData();
1617
1618                                     // Initialize a handler to manually delete the DOM storage files and directories.
1619                                     Handler deleteDomStorageHandler = new Handler();
1620
1621                                     // Setup a runnable to manually delete the DOM storage files and directories.
1622                                     Runnable deleteDomStorageRunnable = () -> {
1623                                         try {
1624                                             // Get a handle for the runtime.
1625                                             Runtime runtime = Runtime.getRuntime();
1626
1627                                             // Get the application's private data directory, which will be something like `/data/user/0/com.stoutner.privacybrowser.standard`,
1628                                             // which links to `/data/data/com.stoutner.privacybrowser.standard`.
1629                                             String privateDataDirectoryString = getApplicationInfo().dataDir;
1630
1631                                             // A string array must be used because the directory contains a space and `Runtime.exec` will otherwise not escape the string correctly.
1632                                             Process deleteLocalStorageProcess = runtime.exec(new String[]{"rm", "-rf", privateDataDirectoryString + "/app_webview/Local Storage/"});
1633
1634                                             // Multiple commands must be used because `Runtime.exec()` does not like `*`.
1635                                             Process deleteIndexProcess = runtime.exec("rm -rf " + privateDataDirectoryString + "/app_webview/IndexedDB");
1636                                             Process deleteQuotaManagerProcess = runtime.exec("rm -f " + privateDataDirectoryString + "/app_webview/QuotaManager");
1637                                             Process deleteQuotaManagerJournalProcess = runtime.exec("rm -f " + privateDataDirectoryString + "/app_webview/QuotaManager-journal");
1638                                             Process deleteDatabasesProcess = runtime.exec("rm -rf " + privateDataDirectoryString + "/app_webview/databases");
1639
1640                                             // Wait for the processes to finish.
1641                                             deleteLocalStorageProcess.waitFor();
1642                                             deleteIndexProcess.waitFor();
1643                                             deleteQuotaManagerProcess.waitFor();
1644                                             deleteQuotaManagerJournalProcess.waitFor();
1645                                             deleteDatabasesProcess.waitFor();
1646                                         } catch (Exception exception) {
1647                                             // Do nothing if an error is thrown.
1648                                         }
1649                                     };
1650
1651                                     // Manually delete the DOM storage files after 200 milliseconds.
1652                                     deleteDomStorageHandler.postDelayed(deleteDomStorageRunnable, 200);
1653                                 }
1654                             }
1655                         })
1656                         .show();
1657                 return true;
1658
1659             // Form data can be remove once the minimum API >= 26.
1660             case R.id.clear_form_data:
1661                 Snackbar.make(findViewById(R.id.webviewpager), R.string.form_data_deleted, Snackbar.LENGTH_LONG)
1662                         .setAction(R.string.undo, v -> {
1663                             // Do nothing because everything will be handled by `onDismissed()` below.
1664                         })
1665                         .addCallback(new Snackbar.Callback() {
1666                             @SuppressLint("SwitchIntDef")  // Ignore the lint warning about not handling the other possible events as they are covered by `default:`.
1667                             @Override
1668                             public void onDismissed(Snackbar snackbar, int event) {
1669                                 if (event != Snackbar.Callback.DISMISS_EVENT_ACTION) {  // The snackbar was dismissed without the undo button being pushed.
1670                                     // Delete the form data.
1671                                     WebViewDatabase mainWebViewDatabase = WebViewDatabase.getInstance(getApplicationContext());
1672                                     mainWebViewDatabase.clearFormData();
1673                                 }
1674                             }
1675                         })
1676                         .show();
1677                 return true;
1678
1679             case R.id.easylist:
1680                 // Toggle the EasyList status.
1681                 currentWebView.enableBlocklist(NestedScrollWebView.EASY_LIST, !currentWebView.isBlocklistEnabled(NestedScrollWebView.EASY_LIST));
1682
1683                 // Update the menu checkbox.
1684                 menuItem.setChecked(currentWebView.isBlocklistEnabled(NestedScrollWebView.EASY_LIST));
1685
1686                 // Reload the current WebView.
1687                 currentWebView.reload();
1688                 return true;
1689
1690             case R.id.easyprivacy:
1691                 // Toggle the EasyPrivacy status.
1692                 currentWebView.enableBlocklist(NestedScrollWebView.EASY_PRIVACY, !currentWebView.isBlocklistEnabled(NestedScrollWebView.EASY_PRIVACY));
1693
1694                 // Update the menu checkbox.
1695                 menuItem.setChecked(currentWebView.isBlocklistEnabled(NestedScrollWebView.EASY_PRIVACY));
1696
1697                 // Reload the current WebView.
1698                 currentWebView.reload();
1699                 return true;
1700
1701             case R.id.fanboys_annoyance_list:
1702                 // Toggle Fanboy's Annoyance List status.
1703                 currentWebView.enableBlocklist(NestedScrollWebView.FANBOYS_ANNOYANCE_LIST, !currentWebView.isBlocklistEnabled(NestedScrollWebView.FANBOYS_ANNOYANCE_LIST));
1704
1705                 // Update the menu checkbox.
1706                 menuItem.setChecked(currentWebView.isBlocklistEnabled(NestedScrollWebView.FANBOYS_ANNOYANCE_LIST));
1707
1708                 // Update the staus of Fanboy's Social Blocking List.
1709                 MenuItem fanboysSocialBlockingListMenuItem = optionsMenu.findItem(R.id.fanboys_social_blocking_list);
1710                 fanboysSocialBlockingListMenuItem.setEnabled(!currentWebView.isBlocklistEnabled(NestedScrollWebView.FANBOYS_ANNOYANCE_LIST));
1711
1712                 // Reload the current WebView.
1713                 currentWebView.reload();
1714                 return true;
1715
1716             case R.id.fanboys_social_blocking_list:
1717                 // Toggle Fanboy's Social Blocking List status.
1718                 currentWebView.enableBlocklist(NestedScrollWebView.FANBOYS_SOCIAL_BLOCKING_LIST, !currentWebView.isBlocklistEnabled(NestedScrollWebView.FANBOYS_SOCIAL_BLOCKING_LIST));
1719
1720                 // Update the menu checkbox.
1721                 menuItem.setChecked(currentWebView.isBlocklistEnabled(NestedScrollWebView.FANBOYS_SOCIAL_BLOCKING_LIST));
1722
1723                 // Reload the current WebView.
1724                 currentWebView.reload();
1725                 return true;
1726
1727             case R.id.ultraprivacy:
1728                 // Toggle the UltraPrivacy status.
1729                 currentWebView.enableBlocklist(NestedScrollWebView.ULTRA_PRIVACY, !currentWebView.isBlocklistEnabled(NestedScrollWebView.ULTRA_PRIVACY));
1730
1731                 // Update the menu checkbox.
1732                 menuItem.setChecked(currentWebView.isBlocklistEnabled(NestedScrollWebView.ULTRA_PRIVACY));
1733
1734                 // Reload the current WebView.
1735                 currentWebView.reload();
1736                 return true;
1737
1738             case R.id.block_all_third_party_requests:
1739                 //Toggle the third-party requests blocker status.
1740                 currentWebView.enableBlocklist(NestedScrollWebView.THIRD_PARTY_REQUESTS, !currentWebView.isBlocklistEnabled(NestedScrollWebView.THIRD_PARTY_REQUESTS));
1741
1742                 // Update the menu checkbox.
1743                 menuItem.setChecked(currentWebView.isBlocklistEnabled(NestedScrollWebView.THIRD_PARTY_REQUESTS));
1744
1745                 // Reload the current WebView.
1746                 currentWebView.reload();
1747                 return true;
1748
1749             case R.id.user_agent_privacy_browser:
1750                 // Update the user agent.
1751                 currentWebView.getSettings().setUserAgentString(getResources().getStringArray(R.array.user_agent_data)[0]);
1752
1753                 // Reload the current WebView.
1754                 currentWebView.reload();
1755                 return true;
1756
1757             case R.id.user_agent_webview_default:
1758                 // Update the user agent.
1759                 currentWebView.getSettings().setUserAgentString("");
1760
1761                 // Reload the current WebView.
1762                 currentWebView.reload();
1763                 return true;
1764
1765             case R.id.user_agent_firefox_on_android:
1766                 // Update the user agent.
1767                 currentWebView.getSettings().setUserAgentString(getResources().getStringArray(R.array.user_agent_data)[2]);
1768
1769                 // Reload the current WebView.
1770                 currentWebView.reload();
1771                 return true;
1772
1773             case R.id.user_agent_chrome_on_android:
1774                 // Update the user agent.
1775                 currentWebView.getSettings().setUserAgentString(getResources().getStringArray(R.array.user_agent_data)[3]);
1776
1777                 // Reload the current WebView.
1778                 currentWebView.reload();
1779                 return true;
1780
1781             case R.id.user_agent_safari_on_ios:
1782                 // Update the user agent.
1783                 currentWebView.getSettings().setUserAgentString(getResources().getStringArray(R.array.user_agent_data)[4]);
1784
1785                 // Reload the current WebView.
1786                 currentWebView.reload();
1787                 return true;
1788
1789             case R.id.user_agent_firefox_on_linux:
1790                 // Update the user agent.
1791                 currentWebView.getSettings().setUserAgentString(getResources().getStringArray(R.array.user_agent_data)[5]);
1792
1793                 // Reload the current WebView.
1794                 currentWebView.reload();
1795                 return true;
1796
1797             case R.id.user_agent_chromium_on_linux:
1798                 // Update the user agent.
1799                 currentWebView.getSettings().setUserAgentString(getResources().getStringArray(R.array.user_agent_data)[6]);
1800
1801                 // Reload the current WebView.
1802                 currentWebView.reload();
1803                 return true;
1804
1805             case R.id.user_agent_firefox_on_windows:
1806                 // Update the user agent.
1807                 currentWebView.getSettings().setUserAgentString(getResources().getStringArray(R.array.user_agent_data)[7]);
1808
1809                 // Reload the current WebView.
1810                 currentWebView.reload();
1811                 return true;
1812
1813             case R.id.user_agent_chrome_on_windows:
1814                 // Update the user agent.
1815                 currentWebView.getSettings().setUserAgentString(getResources().getStringArray(R.array.user_agent_data)[8]);
1816
1817                 // Reload the current WebView.
1818                 currentWebView.reload();
1819                 return true;
1820
1821             case R.id.user_agent_edge_on_windows:
1822                 // Update the user agent.
1823                 currentWebView.getSettings().setUserAgentString(getResources().getStringArray(R.array.user_agent_data)[9]);
1824
1825                 // Reload the current WebView.
1826                 currentWebView.reload();
1827                 return true;
1828
1829             case R.id.user_agent_internet_explorer_on_windows:
1830                 // Update the user agent.
1831                 currentWebView.getSettings().setUserAgentString(getResources().getStringArray(R.array.user_agent_data)[10]);
1832
1833                 // Reload the current WebView.
1834                 currentWebView.reload();
1835                 return true;
1836
1837             case R.id.user_agent_safari_on_macos:
1838                 // Update the user agent.
1839                 currentWebView.getSettings().setUserAgentString(getResources().getStringArray(R.array.user_agent_data)[11]);
1840
1841                 // Reload the current WebView.
1842                 currentWebView.reload();
1843                 return true;
1844
1845             case R.id.user_agent_custom:
1846                 // Update the user agent.
1847                 currentWebView.getSettings().setUserAgentString(sharedPreferences.getString("custom_user_agent", getString(R.string.custom_user_agent_default_value)));
1848
1849                 // Reload the current WebView.
1850                 currentWebView.reload();
1851                 return true;
1852
1853             case R.id.font_size_twenty_five_percent:
1854                 currentWebView.getSettings().setTextZoom(25);
1855                 return true;
1856
1857             case R.id.font_size_fifty_percent:
1858                 currentWebView.getSettings().setTextZoom(50);
1859                 return true;
1860
1861             case R.id.font_size_seventy_five_percent:
1862                 currentWebView.getSettings().setTextZoom(75);
1863                 return true;
1864
1865             case R.id.font_size_one_hundred_percent:
1866                 currentWebView.getSettings().setTextZoom(100);
1867                 return true;
1868
1869             case R.id.font_size_one_hundred_twenty_five_percent:
1870                 currentWebView.getSettings().setTextZoom(125);
1871                 return true;
1872
1873             case R.id.font_size_one_hundred_fifty_percent:
1874                 currentWebView.getSettings().setTextZoom(150);
1875                 return true;
1876
1877             case R.id.font_size_one_hundred_seventy_five_percent:
1878                 currentWebView.getSettings().setTextZoom(175);
1879                 return true;
1880
1881             case R.id.font_size_two_hundred_percent:
1882                 currentWebView.getSettings().setTextZoom(200);
1883                 return true;
1884
1885             case R.id.swipe_to_refresh:
1886                 // Toggle the stored status of swipe to refresh.
1887                 currentWebView.setSwipeToRefresh(!currentWebView.getSwipeToRefresh());
1888
1889                 // Get a handle for the swipe refresh layout.
1890                 SwipeRefreshLayout swipeRefreshLayout = findViewById(R.id.swiperefreshlayout);
1891
1892                 // Update the swipe refresh layout.
1893                 if (currentWebView.getSwipeToRefresh()) {  // Swipe to refresh is enabled.
1894                     // Only enable the swipe refresh layout if the WebView is scrolled to the top.  It is updated every time the scroll changes.
1895                     swipeRefreshLayout.setEnabled(currentWebView.getY() == 0);
1896                 } else {  // Swipe to refresh is disabled.
1897                     // Disable the swipe refresh layout.
1898                     swipeRefreshLayout.setEnabled(false);
1899                 }
1900                 return true;
1901
1902             case R.id.wide_viewport:
1903                 // Toggle the viewport.
1904                 currentWebView.getSettings().setUseWideViewPort(!currentWebView.getSettings().getUseWideViewPort());
1905                 return true;
1906
1907             case R.id.display_images:
1908                 if (currentWebView.getSettings().getLoadsImagesAutomatically()) {  // Images are currently loaded automatically.
1909                     // Disable loading of images.
1910                     currentWebView.getSettings().setLoadsImagesAutomatically(false);
1911
1912                     // Reload the website to remove existing images.
1913                     currentWebView.reload();
1914                 } else {  // Images are not currently loaded automatically.
1915                     // Enable loading of images.  Missing images will be loaded without the need for a reload.
1916                     currentWebView.getSettings().setLoadsImagesAutomatically(true);
1917                 }
1918                 return true;
1919
1920             case R.id.night_mode:
1921                 // Toggle night mode.
1922                 currentWebView.setNightMode(!currentWebView.getNightMode());
1923
1924                 // Enable or disable JavaScript according to night mode, the global preference, and any domain settings.
1925                 if (currentWebView.getNightMode()) {  // Night mode is enabled, which requires JavaScript.
1926                     // Enable JavaScript.
1927                     currentWebView.getSettings().setJavaScriptEnabled(true);
1928                 } else if (currentWebView.getDomainSettingsApplied()) {  // Night mode is disabled and domain settings are applied.  Set JavaScript according to the domain settings.
1929                     // Apply the JavaScript preference that was stored the last time domain settings were loaded.
1930                     currentWebView.getSettings().setJavaScriptEnabled(currentWebView.getDomainSettingsJavaScriptEnabled());
1931                 } else {  // Night mode is disabled and domain settings are not applied.  Set JavaScript according to the global preference.
1932                     // Apply the JavaScript preference.
1933                     currentWebView.getSettings().setJavaScriptEnabled(sharedPreferences.getBoolean("javascript", false));
1934                 }
1935
1936                 // Update the privacy icons.
1937                 updatePrivacyIcons(false);
1938
1939                 // Reload the website.
1940                 currentWebView.reload();
1941                 return true;
1942
1943             case R.id.find_on_page:
1944                 // Get a handle for the views.
1945                 Toolbar toolbar = findViewById(R.id.toolbar);
1946                 LinearLayout findOnPageLinearLayout = findViewById(R.id.find_on_page_linearlayout);
1947                 EditText findOnPageEditText = findViewById(R.id.find_on_page_edittext);
1948
1949                 // Set the minimum height of the find on page linear layout to match the toolbar.
1950                 findOnPageLinearLayout.setMinimumHeight(toolbar.getHeight());
1951
1952                 // Hide the toolbar.
1953                 toolbar.setVisibility(View.GONE);
1954
1955                 // Show the find on page linear layout.
1956                 findOnPageLinearLayout.setVisibility(View.VISIBLE);
1957
1958                 // Display the keyboard.  The app must wait 200 ms before running the command to work around a bug in Android.
1959                 // http://stackoverflow.com/questions/5520085/android-show-softkeyboard-with-showsoftinput-is-not-working
1960                 findOnPageEditText.postDelayed(() -> {
1961                     // Set the focus on `findOnPageEditText`.
1962                     findOnPageEditText.requestFocus();
1963
1964                     // Get a handle for the input method manager.
1965                     InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
1966
1967                     // Remove the lint warning below that the input method manager might be null.
1968                     assert inputMethodManager != null;
1969
1970                     // Display the keyboard.  `0` sets no input flags.
1971                     inputMethodManager.showSoftInput(findOnPageEditText, 0);
1972                 }, 200);
1973                 return true;
1974
1975             case R.id.print:
1976                 // Get a print manager instance.
1977                 PrintManager printManager = (PrintManager) getSystemService(Context.PRINT_SERVICE);
1978
1979                 // Remove the lint error below that print manager might be null.
1980                 assert printManager != null;
1981
1982                 // Create a print document adapter from the current WebView.
1983                 PrintDocumentAdapter printDocumentAdapter = currentWebView.createPrintDocumentAdapter();
1984
1985                 // Print the document.
1986                 printManager.print(getString(R.string.privacy_browser_web_page), printDocumentAdapter, null);
1987                 return true;
1988
1989             case R.id.add_to_homescreen:
1990                 // Instantiate the create home screen shortcut dialog.
1991                 DialogFragment createHomeScreenShortcutDialogFragment = CreateHomeScreenShortcutDialog.createDialog(currentWebView.getTitle(), currentWebView.getUrl(),
1992                         currentWebView.getFavoriteOrDefaultIcon());
1993
1994                 // Show the create home screen shortcut dialog.
1995                 createHomeScreenShortcutDialogFragment.show(getSupportFragmentManager(), getString(R.string.create_shortcut));
1996                 return true;
1997
1998             case R.id.view_source:
1999                 // Create an intent to launch the view source activity.
2000                 Intent viewSourceIntent = new Intent(this, ViewSourceActivity.class);
2001
2002                 // Add the variables to the intent.
2003                 viewSourceIntent.putExtra("user_agent", currentWebView.getSettings().getUserAgentString());
2004                 viewSourceIntent.putExtra("current_url", currentWebView.getUrl());
2005
2006                 // Make it so.
2007                 startActivity(viewSourceIntent);
2008                 return true;
2009
2010             case R.id.share_url:
2011                 // Setup the share string.
2012                 String shareString = currentWebView.getTitle() + " – " + currentWebView.getUrl();
2013
2014                 // Create the share intent.
2015                 Intent shareIntent = new Intent(Intent.ACTION_SEND);
2016                 shareIntent.putExtra(Intent.EXTRA_TEXT, shareString);
2017                 shareIntent.setType("text/plain");
2018
2019                 // Make it so.
2020                 startActivity(Intent.createChooser(shareIntent, getString(R.string.share_url)));
2021                 return true;
2022
2023             case R.id.open_with_app:
2024                 openWithApp(currentWebView.getUrl());
2025                 return true;
2026
2027             case R.id.open_with_browser:
2028                 openWithBrowser(currentWebView.getUrl());
2029                 return true;
2030
2031             case R.id.proxy_through_orbot:
2032                 // Toggle the proxy through Orbot variable.
2033                 proxyThroughOrbot = !proxyThroughOrbot;
2034
2035                 // Apply the proxy through Orbot settings.
2036                 applyProxyThroughOrbot(true);
2037                 return true;
2038
2039             case R.id.refresh:
2040                 if (menuItem.getTitle().equals(getString(R.string.refresh))) {  // The refresh button was pushed.
2041                     // Reload the current WebView.
2042                     currentWebView.reload();
2043                 } else {  // The stop button was pushed.
2044                     // Stop the loading of the WebView.
2045                     currentWebView.stopLoading();
2046                 }
2047                 return true;
2048
2049             case R.id.ad_consent:
2050                 // Display the ad consent dialog.
2051                 DialogFragment adConsentDialogFragment = new AdConsentDialog();
2052                 adConsentDialogFragment.show(getSupportFragmentManager(), getString(R.string.ad_consent));
2053                 return true;
2054
2055             default:
2056                 // Don't consume the event.
2057                 return super.onOptionsItemSelected(menuItem);
2058         }
2059     }
2060
2061     // removeAllCookies is deprecated, but it is required for API < 21.
2062     @Override
2063     public boolean onNavigationItemSelected(@NonNull MenuItem menuItem) {
2064         // Get the menu item ID.
2065         int menuItemId = menuItem.getItemId();
2066
2067         // Get a handle for the shared preferences.
2068         SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(this);
2069
2070         // Run the commands that correspond to the selected menu item.
2071         switch (menuItemId) {
2072             case R.id.clear_and_exit:
2073                 // Clear and exit Privacy Browser.
2074                 clearAndExit();
2075                 break;
2076
2077             case R.id.home:
2078                 // Select the homepage based on the proxy through Orbot status.
2079                 if (proxyThroughOrbot) {
2080                     // Load the Tor homepage.
2081                     loadUrl(sharedPreferences.getString("tor_homepage", getString(R.string.tor_homepage_default_value)));
2082                 } else {
2083                     // Load the normal homepage.
2084                     loadUrl(sharedPreferences.getString("homepage", getString(R.string.homepage_default_value)));
2085                 }
2086                 break;
2087
2088             case R.id.back:
2089                 if (currentWebView.canGoBack()) {
2090                     // Reset the current domain name so that navigation works if third-party requests are blocked.
2091                     currentWebView.resetCurrentDomainName();
2092
2093                     // Set navigating history so that the domain settings are applied when the new URL is loaded.
2094                     currentWebView.setNavigatingHistory(true);
2095
2096                     // Load the previous website in the history.
2097                     currentWebView.goBack();
2098                 }
2099                 break;
2100
2101             case R.id.forward:
2102                 if (currentWebView.canGoForward()) {
2103                     // Reset the current domain name so that navigation works if third-party requests are blocked.
2104                     currentWebView.resetCurrentDomainName();
2105
2106                     // Set navigating history so that the domain settings are applied when the new URL is loaded.
2107                     currentWebView.setNavigatingHistory(true);
2108
2109                     // Load the next website in the history.
2110                     currentWebView.goForward();
2111                 }
2112                 break;
2113
2114             case R.id.history:
2115                 // Instantiate the URL history dialog.
2116                 DialogFragment urlHistoryDialogFragment = UrlHistoryDialog.loadBackForwardList(currentWebView.getWebViewFragmentId());
2117
2118                 // Show the URL history dialog.
2119                 urlHistoryDialogFragment.show(getSupportFragmentManager(), getString(R.string.history));
2120                 break;
2121
2122             case R.id.requests:
2123                 // Populate the resource requests.
2124                 RequestsActivity.resourceRequests = currentWebView.getResourceRequests();
2125
2126                 // Create an intent to launch the Requests activity.
2127                 Intent requestsIntent = new Intent(this, RequestsActivity.class);
2128
2129                 // Add the block third-party requests status to the intent.
2130                 requestsIntent.putExtra("block_all_third_party_requests", currentWebView.isBlocklistEnabled(NestedScrollWebView.THIRD_PARTY_REQUESTS));
2131
2132                 // Make it so.
2133                 startActivity(requestsIntent);
2134                 break;
2135
2136             case R.id.downloads:
2137                 // Launch the system Download Manager.
2138                 Intent downloadManagerIntent = new Intent(DownloadManager.ACTION_VIEW_DOWNLOADS);
2139
2140                 // Launch as a new task so that Download Manager and Privacy Browser show as separate windows in the recent tasks list.
2141                 downloadManagerIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
2142
2143                 startActivity(downloadManagerIntent);
2144                 break;
2145
2146             case R.id.domains:
2147                 // Set the flag to reapply the domain settings on restart when returning from Domain Settings.
2148                 reapplyDomainSettingsOnRestart = true;
2149
2150                 // Launch the domains activity.
2151                 Intent domainsIntent = new Intent(this, DomainsActivity.class);
2152
2153                 // Add the extra information to the intent.
2154                 domainsIntent.putExtra("current_url", currentWebView.getUrl());
2155
2156                 // Get the current certificate.
2157                 SslCertificate sslCertificate = currentWebView.getCertificate();
2158
2159                 // Check to see if the SSL certificate is populated.
2160                 if (sslCertificate != null) {
2161                     // Extract the certificate to strings.
2162                     String issuedToCName = sslCertificate.getIssuedTo().getCName();
2163                     String issuedToOName = sslCertificate.getIssuedTo().getOName();
2164                     String issuedToUName = sslCertificate.getIssuedTo().getUName();
2165                     String issuedByCName = sslCertificate.getIssuedBy().getCName();
2166                     String issuedByOName = sslCertificate.getIssuedBy().getOName();
2167                     String issuedByUName = sslCertificate.getIssuedBy().getUName();
2168                     long startDateLong = sslCertificate.getValidNotBeforeDate().getTime();
2169                     long endDateLong = sslCertificate.getValidNotAfterDate().getTime();
2170
2171                     // Add the certificate to the intent.
2172                     domainsIntent.putExtra("ssl_issued_to_cname", issuedToCName);
2173                     domainsIntent.putExtra("ssl_issued_to_oname", issuedToOName);
2174                     domainsIntent.putExtra("ssl_issued_to_uname", issuedToUName);
2175                     domainsIntent.putExtra("ssl_issued_by_cname", issuedByCName);
2176                     domainsIntent.putExtra("ssl_issued_by_oname", issuedByOName);
2177                     domainsIntent.putExtra("ssl_issued_by_uname", issuedByUName);
2178                     domainsIntent.putExtra("ssl_start_date", startDateLong);
2179                     domainsIntent.putExtra("ssl_end_date", endDateLong);
2180                 }
2181
2182                 // Check to see if the current IP addresses have been received.
2183                 if (currentWebView.hasCurrentIpAddresses()) {
2184                     // Add the current IP addresses to the intent.
2185                     domainsIntent.putExtra("current_ip_addresses", currentWebView.getCurrentIpAddresses());
2186                 }
2187
2188                 // Make it so.
2189                 startActivity(domainsIntent);
2190                 break;
2191
2192             case R.id.settings:
2193                 // Set the flag to reapply app settings on restart when returning from Settings.
2194                 reapplyAppSettingsOnRestart = true;
2195
2196                 // Set the flag to reapply the domain settings on restart when returning from Settings.
2197                 reapplyDomainSettingsOnRestart = true;
2198
2199                 // Launch the settings activity.
2200                 Intent settingsIntent = new Intent(this, SettingsActivity.class);
2201                 startActivity(settingsIntent);
2202                 break;
2203
2204             case R.id.import_export:
2205                 // Launch the import/export activity.
2206                 Intent importExportIntent = new Intent (this, ImportExportActivity.class);
2207                 startActivity(importExportIntent);
2208                 break;
2209
2210             case R.id.logcat:
2211                 // Launch the logcat activity.
2212                 Intent logcatIntent = new Intent(this, LogcatActivity.class);
2213                 startActivity(logcatIntent);
2214                 break;
2215
2216             case R.id.guide:
2217                 // Launch `GuideActivity`.
2218                 Intent guideIntent = new Intent(this, GuideActivity.class);
2219                 startActivity(guideIntent);
2220                 break;
2221
2222             case R.id.about:
2223                 // Create an intent to launch the about activity.
2224                 Intent aboutIntent = new Intent(this, AboutActivity.class);
2225
2226                 // Create a string array for the blocklist versions.
2227                 String[] blocklistVersions = new String[] {easyList.get(0).get(0)[0], easyPrivacy.get(0).get(0)[0], fanboysAnnoyanceList.get(0).get(0)[0], fanboysSocialList.get(0).get(0)[0],
2228                         ultraPrivacy.get(0).get(0)[0]};
2229
2230                 // Add the blocklist versions to the intent.
2231                 aboutIntent.putExtra("blocklist_versions", blocklistVersions);
2232
2233                 // Make it so.
2234                 startActivity(aboutIntent);
2235                 break;
2236         }
2237
2238         // Get a handle for the drawer layout.
2239         DrawerLayout drawerLayout = findViewById(R.id.drawerlayout);
2240
2241         // Close the navigation drawer.
2242         drawerLayout.closeDrawer(GravityCompat.START);
2243         return true;
2244     }
2245
2246     @Override
2247     public void onPostCreate(Bundle savedInstanceState) {
2248         // Run the default commands.
2249         super.onPostCreate(savedInstanceState);
2250
2251         // Sync the state of the DrawerToggle after the default `onRestoreInstanceState()` has finished.  This creates the navigation drawer icon.
2252         actionBarDrawerToggle.syncState();
2253     }
2254
2255     @Override
2256     public void onConfigurationChanged(Configuration newConfig) {
2257         // Run the default commands.
2258         super.onConfigurationChanged(newConfig);
2259
2260         // Get the status bar pixel size.
2261         int statusBarResourceId = getResources().getIdentifier("status_bar_height", "dimen", "android");
2262         int statusBarPixelSize = getResources().getDimensionPixelSize(statusBarResourceId);
2263
2264         // Get the resource density.
2265         float screenDensity = getResources().getDisplayMetrics().density;
2266
2267         // Recalculate the drawer header padding.
2268         drawerHeaderPaddingLeftAndRight = (int) (15 * screenDensity);
2269         drawerHeaderPaddingTop = statusBarPixelSize + (int) (4 * screenDensity);
2270         drawerHeaderPaddingBottom = (int) (8 * screenDensity);
2271
2272         // Reload the ad for the free flavor if not in full screen mode.
2273         if (BuildConfig.FLAVOR.contentEquals("free") && !inFullScreenBrowsingMode) {
2274             // Reload the ad.  The AdView is destroyed and recreated, which changes the ID, every time it is reloaded to handle possible rotations.
2275             AdHelper.loadAd(findViewById(R.id.adview), getApplicationContext(), getString(R.string.ad_unit_id));
2276         }
2277
2278         // `invalidateOptionsMenu` should recalculate the number of action buttons from the menu to display on the app bar, but it doesn't because of the this bug:
2279         // https://code.google.com/p/android/issues/detail?id=20493#c8
2280         // ActivityCompat.invalidateOptionsMenu(this);
2281     }
2282
2283     @Override
2284     public void onCreateContextMenu(ContextMenu menu, View view, ContextMenu.ContextMenuInfo menuInfo) {
2285         // Store the hit test result.
2286         final WebView.HitTestResult hitTestResult = currentWebView.getHitTestResult();
2287
2288         // Create the URL strings.
2289         final String imageUrl;
2290         final String linkUrl;
2291
2292         // Get handles for the system managers.
2293         final ClipboardManager clipboardManager = (ClipboardManager) getSystemService(CLIPBOARD_SERVICE);
2294         FragmentManager fragmentManager = getSupportFragmentManager();
2295         SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(this);
2296
2297         // Remove the lint errors below that the clipboard manager might be null.
2298         assert clipboardManager != null;
2299
2300         // Process the link according to the type.
2301         switch (hitTestResult.getType()) {
2302             // `SRC_ANCHOR_TYPE` is a link.
2303             case WebView.HitTestResult.SRC_ANCHOR_TYPE:
2304                 // Get the target URL.
2305                 linkUrl = hitTestResult.getExtra();
2306
2307                 // Set the target URL as the title of the `ContextMenu`.
2308                 menu.setHeaderTitle(linkUrl);
2309
2310                 // Add an Open in New Tab entry.
2311                 menu.add(R.string.open_in_new_tab).setOnMenuItemClickListener((MenuItem item) -> {
2312                     // Load the link URL in a new tab.
2313                     addNewTab(linkUrl);
2314                     return false;
2315                 });
2316
2317                 // Add an Open with App entry.
2318                 menu.add(R.string.open_with_app).setOnMenuItemClickListener((MenuItem item) -> {
2319                     openWithApp(linkUrl);
2320                     return false;
2321                 });
2322
2323                 // Add an Open with Browser entry.
2324                 menu.add(R.string.open_with_browser).setOnMenuItemClickListener((MenuItem item) -> {
2325                     openWithBrowser(linkUrl);
2326                     return false;
2327                 });
2328
2329                 // Add a Copy URL entry.
2330                 menu.add(R.string.copy_url).setOnMenuItemClickListener((MenuItem item) -> {
2331                     // Save the link URL in a `ClipData`.
2332                     ClipData srcAnchorTypeClipData = ClipData.newPlainText(getString(R.string.url), linkUrl);
2333
2334                     // Set the `ClipData` as the clipboard's primary clip.
2335                     clipboardManager.setPrimaryClip(srcAnchorTypeClipData);
2336                     return false;
2337                 });
2338
2339                 // Add a Download URL entry.
2340                 menu.add(R.string.download_url).setOnMenuItemClickListener((MenuItem item) -> {
2341                     // Check if the download should be processed by an external app.
2342                     if (sharedPreferences.getBoolean("download_with_external_app", false)) {  // Download with an external app.
2343                         openUrlWithExternalApp(linkUrl);
2344                     } else {  // Download with Android's download manager.
2345                         // Check to see if the storage permission has already been granted.
2346                         if (ContextCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE) == PackageManager.PERMISSION_DENIED) {  // The storage permission needs to be requested.
2347                             // Store the variables for future use by `onRequestPermissionsResult()`.
2348                             downloadUrl = linkUrl;
2349                             downloadContentDisposition = "none";
2350                             downloadContentLength = -1;
2351
2352                             // Show a dialog if the user has previously denied the permission.
2353                             if (ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.WRITE_EXTERNAL_STORAGE)) {  // Show a dialog explaining the request first.
2354                                 // Instantiate the download location permission alert dialog and set the download type to DOWNLOAD_FILE.
2355                                 DialogFragment downloadLocationPermissionDialogFragment = DownloadLocationPermissionDialog.downloadType(DownloadLocationPermissionDialog.DOWNLOAD_FILE);
2356
2357                                 // Show the download location permission alert dialog.  The permission will be requested when the the dialog is closed.
2358                                 downloadLocationPermissionDialogFragment.show(fragmentManager, getString(R.string.download_location));
2359                             } else {  // Show the permission request directly.
2360                                 // Request the permission.  The download dialog will be launched by `onRequestPermissionResult()`.
2361                                 ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE}, DOWNLOAD_FILE_REQUEST_CODE);
2362                             }
2363                         } else {  // The storage permission has already been granted.
2364                             // Get a handle for the download file alert dialog.
2365                             DialogFragment downloadFileDialogFragment = DownloadFileDialog.fromUrl(linkUrl, "none", -1);
2366
2367                             // Show the download file alert dialog.
2368                             downloadFileDialogFragment.show(fragmentManager, getString(R.string.download));
2369                         }
2370                     }
2371                     return false;
2372                 });
2373
2374                 // Add a Cancel entry, which by default closes the context menu.
2375                 menu.add(R.string.cancel);
2376                 break;
2377
2378             case WebView.HitTestResult.EMAIL_TYPE:
2379                 // Get the target URL.
2380                 linkUrl = hitTestResult.getExtra();
2381
2382                 // Set the target URL as the title of the `ContextMenu`.
2383                 menu.setHeaderTitle(linkUrl);
2384
2385                 // Add a Write Email entry.
2386                 menu.add(R.string.write_email).setOnMenuItemClickListener(item -> {
2387                     // Use `ACTION_SENDTO` instead of `ACTION_SEND` so that only email programs are launched.
2388                     Intent emailIntent = new Intent(Intent.ACTION_SENDTO);
2389
2390                     // Parse the url and set it as the data for the `Intent`.
2391                     emailIntent.setData(Uri.parse("mailto:" + linkUrl));
2392
2393                     // `FLAG_ACTIVITY_NEW_TASK` opens the email program in a new task instead as part of Privacy Browser.
2394                     emailIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
2395
2396                     // Make it so.
2397                     startActivity(emailIntent);
2398                     return false;
2399                 });
2400
2401                 // Add a Copy Email Address entry.
2402                 menu.add(R.string.copy_email_address).setOnMenuItemClickListener(item -> {
2403                     // Save the email address in a `ClipData`.
2404                     ClipData srcEmailTypeClipData = ClipData.newPlainText(getString(R.string.email_address), linkUrl);
2405
2406                     // Set the `ClipData` as the clipboard's primary clip.
2407                     clipboardManager.setPrimaryClip(srcEmailTypeClipData);
2408                     return false;
2409                 });
2410
2411                 // Add a `Cancel` entry, which by default closes the `ContextMenu`.
2412                 menu.add(R.string.cancel);
2413                 break;
2414
2415             // `IMAGE_TYPE` is an image. `SRC_IMAGE_ANCHOR_TYPE` is an image that is also a link.  Privacy Browser processes them the same.
2416             case WebView.HitTestResult.IMAGE_TYPE:
2417             case WebView.HitTestResult.SRC_IMAGE_ANCHOR_TYPE:
2418                 // Get the image URL.
2419                 imageUrl = hitTestResult.getExtra();
2420
2421                 // Set the image URL as the title of the context menu.
2422                 menu.setHeaderTitle(imageUrl);
2423
2424                 // Add an Open in New Tab entry.
2425                 menu.add(R.string.open_in_new_tab).setOnMenuItemClickListener((MenuItem item) -> {
2426                     // Load the image URL in a new tab.
2427                     addNewTab(imageUrl);
2428                     return false;
2429                 });
2430
2431                 // Add a View Image entry.
2432                 menu.add(R.string.view_image).setOnMenuItemClickListener(item -> {
2433                     loadUrl(imageUrl);
2434                     return false;
2435                 });
2436
2437                 // Add a `Download Image` entry.
2438                 menu.add(R.string.download_image).setOnMenuItemClickListener((MenuItem item) -> {
2439                     // Check if the download should be processed by an external app.
2440                     if (sharedPreferences.getBoolean("download_with_external_app", false)) {  // Download with an external app.
2441                         openUrlWithExternalApp(imageUrl);
2442                     } else {  // Download with Android's download manager.
2443                         // Check to see if the storage permission has already been granted.
2444                         if (ContextCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE) == PackageManager.PERMISSION_DENIED) {  // The storage permission needs to be requested.
2445                             // Store the image URL for use by `onRequestPermissionResult()`.
2446                             downloadImageUrl = imageUrl;
2447
2448                             // Show a dialog if the user has previously denied the permission.
2449                             if (ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.WRITE_EXTERNAL_STORAGE)) {  // Show a dialog explaining the request first.
2450                                 // Instantiate the download location permission alert dialog and set the download type to DOWNLOAD_IMAGE.
2451                                 DialogFragment downloadLocationPermissionDialogFragment = DownloadLocationPermissionDialog.downloadType(DownloadLocationPermissionDialog.DOWNLOAD_IMAGE);
2452
2453                                 // Show the download location permission alert dialog.  The permission will be requested when the dialog is closed.
2454                                 downloadLocationPermissionDialogFragment.show(fragmentManager, getString(R.string.download_location));
2455                             } else {  // Show the permission request directly.
2456                                 // Request the permission.  The download dialog will be launched by `onRequestPermissionResult().
2457                                 ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE}, DOWNLOAD_IMAGE_REQUEST_CODE);
2458                             }
2459                         } else {  // The storage permission has already been granted.
2460                             // Get a handle for the download image alert dialog.
2461                             DialogFragment downloadImageDialogFragment = DownloadImageDialog.imageUrl(imageUrl);
2462
2463                             // Show the download image alert dialog.
2464                             downloadImageDialogFragment.show(fragmentManager, getString(R.string.download));
2465                         }
2466                     }
2467                     return false;
2468                 });
2469
2470                 // Add a `Copy URL` entry.
2471                 menu.add(R.string.copy_url).setOnMenuItemClickListener(item -> {
2472                     // Save the image URL in a `ClipData`.
2473                     ClipData srcImageAnchorTypeClipData = ClipData.newPlainText(getString(R.string.url), imageUrl);
2474
2475                     // Set the `ClipData` as the clipboard's primary clip.
2476                     clipboardManager.setPrimaryClip(srcImageAnchorTypeClipData);
2477                     return false;
2478                 });
2479
2480                 // Add an Open with App entry.
2481                 menu.add(R.string.open_with_app).setOnMenuItemClickListener((MenuItem item) -> {
2482                     openWithApp(imageUrl);
2483                     return false;
2484                 });
2485
2486                 // Add an Open with Browser entry.
2487                 menu.add(R.string.open_with_browser).setOnMenuItemClickListener((MenuItem item) -> {
2488                     openWithBrowser(imageUrl);
2489                     return false;
2490                 });
2491
2492                 // Add a `Cancel` entry, which by default closes the `ContextMenu`.
2493                 menu.add(R.string.cancel);
2494                 break;
2495         }
2496     }
2497
2498     @Override
2499     public void onCreateBookmark(DialogFragment dialogFragment, Bitmap favoriteIconBitmap) {
2500         // Get a handle for the bookmarks list view.
2501         ListView bookmarksListView = findViewById(R.id.bookmarks_drawer_listview);
2502
2503         // Get the views from the dialog fragment.
2504         EditText createBookmarkNameEditText = dialogFragment.getDialog().findViewById(R.id.create_bookmark_name_edittext);
2505         EditText createBookmarkUrlEditText = dialogFragment.getDialog().findViewById(R.id.create_bookmark_url_edittext);
2506
2507         // Extract the strings from the edit texts.
2508         String bookmarkNameString = createBookmarkNameEditText.getText().toString();
2509         String bookmarkUrlString = createBookmarkUrlEditText.getText().toString();
2510
2511         // Create a favorite icon byte array output stream.
2512         ByteArrayOutputStream favoriteIconByteArrayOutputStream = new ByteArrayOutputStream();
2513
2514         // Convert the favorite icon bitmap to a byte array.  `0` is for lossless compression (the only option for a PNG).
2515         favoriteIconBitmap.compress(Bitmap.CompressFormat.PNG, 0, favoriteIconByteArrayOutputStream);
2516
2517         // Convert the favorite icon byte array stream to a byte array.
2518         byte[] favoriteIconByteArray = favoriteIconByteArrayOutputStream.toByteArray();
2519
2520         // Display the new bookmark below the current items in the (0 indexed) list.
2521         int newBookmarkDisplayOrder = bookmarksListView.getCount();
2522
2523         // Create the bookmark.
2524         bookmarksDatabaseHelper.createBookmark(bookmarkNameString, bookmarkUrlString, currentBookmarksFolder, newBookmarkDisplayOrder, favoriteIconByteArray);
2525
2526         // Update the bookmarks cursor with the current contents of this folder.
2527         bookmarksCursor = bookmarksDatabaseHelper.getBookmarksByDisplayOrder(currentBookmarksFolder);
2528
2529         // Update the list view.
2530         bookmarksCursorAdapter.changeCursor(bookmarksCursor);
2531
2532         // Scroll to the new bookmark.
2533         bookmarksListView.setSelection(newBookmarkDisplayOrder);
2534     }
2535
2536     @Override
2537     public void onCreateBookmarkFolder(DialogFragment dialogFragment, Bitmap favoriteIconBitmap) {
2538         // Get a handle for the bookmarks list view.
2539         ListView bookmarksListView = findViewById(R.id.bookmarks_drawer_listview);
2540
2541         // Get handles for the views in the dialog fragment.
2542         EditText createFolderNameEditText = dialogFragment.getDialog().findViewById(R.id.create_folder_name_edittext);
2543         RadioButton defaultFolderIconRadioButton = dialogFragment.getDialog().findViewById(R.id.create_folder_default_icon_radiobutton);
2544         ImageView folderIconImageView = dialogFragment.getDialog().findViewById(R.id.create_folder_default_icon);
2545
2546         // Get new folder name string.
2547         String folderNameString = createFolderNameEditText.getText().toString();
2548
2549         // Create a folder icon bitmap.
2550         Bitmap folderIconBitmap;
2551
2552         // Set the folder icon bitmap according to the dialog.
2553         if (defaultFolderIconRadioButton.isChecked()) {  // Use the default folder icon.
2554             // Get the default folder icon drawable.
2555             Drawable folderIconDrawable = folderIconImageView.getDrawable();
2556
2557             // Convert the folder icon drawable to a bitmap drawable.
2558             BitmapDrawable folderIconBitmapDrawable = (BitmapDrawable) folderIconDrawable;
2559
2560             // Convert the folder icon bitmap drawable to a bitmap.
2561             folderIconBitmap = folderIconBitmapDrawable.getBitmap();
2562         } else {  // Use the WebView favorite icon.
2563             // Copy the favorite icon bitmap to the folder icon bitmap.
2564             folderIconBitmap = favoriteIconBitmap;
2565         }
2566
2567         // Create a folder icon byte array output stream.
2568         ByteArrayOutputStream folderIconByteArrayOutputStream = new ByteArrayOutputStream();
2569
2570         // Convert the folder icon bitmap to a byte array.  `0` is for lossless compression (the only option for a PNG).
2571         folderIconBitmap.compress(Bitmap.CompressFormat.PNG, 0, folderIconByteArrayOutputStream);
2572
2573         // Convert the folder icon byte array stream to a byte array.
2574         byte[] folderIconByteArray = folderIconByteArrayOutputStream.toByteArray();
2575
2576         // Move all the bookmarks down one in the display order.
2577         for (int i = 0; i < bookmarksListView.getCount(); i++) {
2578             int databaseId = (int) bookmarksListView.getItemIdAtPosition(i);
2579             bookmarksDatabaseHelper.updateDisplayOrder(databaseId, i + 1);
2580         }
2581
2582         // Create the folder, which will be placed at the top of the `ListView`.
2583         bookmarksDatabaseHelper.createFolder(folderNameString, currentBookmarksFolder, folderIconByteArray);
2584
2585         // Update the bookmarks cursor with the current contents of this folder.
2586         bookmarksCursor = bookmarksDatabaseHelper.getBookmarksByDisplayOrder(currentBookmarksFolder);
2587
2588         // Update the `ListView`.
2589         bookmarksCursorAdapter.changeCursor(bookmarksCursor);
2590
2591         // Scroll to the new folder.
2592         bookmarksListView.setSelection(0);
2593     }
2594
2595     @Override
2596     public void onSaveBookmark(DialogFragment dialogFragment, int selectedBookmarkDatabaseId, Bitmap favoriteIconBitmap) {
2597         // Get handles for the views from `dialogFragment`.
2598         EditText editBookmarkNameEditText = dialogFragment.getDialog().findViewById(R.id.edit_bookmark_name_edittext);
2599         EditText editBookmarkUrlEditText = dialogFragment.getDialog().findViewById(R.id.edit_bookmark_url_edittext);
2600         RadioButton currentBookmarkIconRadioButton = dialogFragment.getDialog().findViewById(R.id.edit_bookmark_current_icon_radiobutton);
2601
2602         // Store the bookmark strings.
2603         String bookmarkNameString = editBookmarkNameEditText.getText().toString();
2604         String bookmarkUrlString = editBookmarkUrlEditText.getText().toString();
2605
2606         // Update the bookmark.
2607         if (currentBookmarkIconRadioButton.isChecked()) {  // Update the bookmark without changing the favorite icon.
2608             bookmarksDatabaseHelper.updateBookmark(selectedBookmarkDatabaseId, bookmarkNameString, bookmarkUrlString);
2609         } else {  // Update the bookmark using the `WebView` favorite icon.
2610             // Create a favorite icon byte array output stream.
2611             ByteArrayOutputStream newFavoriteIconByteArrayOutputStream = new ByteArrayOutputStream();
2612
2613             // Convert the favorite icon bitmap to a byte array.  `0` is for lossless compression (the only option for a PNG).
2614             favoriteIconBitmap.compress(Bitmap.CompressFormat.PNG, 0, newFavoriteIconByteArrayOutputStream);
2615
2616             // Convert the favorite icon byte array stream to a byte array.
2617             byte[] newFavoriteIconByteArray = newFavoriteIconByteArrayOutputStream.toByteArray();
2618
2619             //  Update the bookmark and the favorite icon.
2620             bookmarksDatabaseHelper.updateBookmark(selectedBookmarkDatabaseId, bookmarkNameString, bookmarkUrlString, newFavoriteIconByteArray);
2621         }
2622
2623         // Update the bookmarks cursor with the current contents of this folder.
2624         bookmarksCursor = bookmarksDatabaseHelper.getBookmarksByDisplayOrder(currentBookmarksFolder);
2625
2626         // Update the list view.
2627         bookmarksCursorAdapter.changeCursor(bookmarksCursor);
2628     }
2629
2630     @Override
2631     public void onSaveBookmarkFolder(DialogFragment dialogFragment, int selectedFolderDatabaseId, Bitmap favoriteIconBitmap) {
2632         // Get handles for the views from `dialogFragment`.
2633         EditText editFolderNameEditText = dialogFragment.getDialog().findViewById(R.id.edit_folder_name_edittext);
2634         RadioButton currentFolderIconRadioButton = dialogFragment.getDialog().findViewById(R.id.edit_folder_current_icon_radiobutton);
2635         RadioButton defaultFolderIconRadioButton = dialogFragment.getDialog().findViewById(R.id.edit_folder_default_icon_radiobutton);
2636         ImageView defaultFolderIconImageView = dialogFragment.getDialog().findViewById(R.id.edit_folder_default_icon_imageview);
2637
2638         // Get the new folder name.
2639         String newFolderNameString = editFolderNameEditText.getText().toString();
2640
2641         // Check if the favorite icon has changed.
2642         if (currentFolderIconRadioButton.isChecked()) {  // Only the name has changed.
2643             // Update the name in the database.
2644             bookmarksDatabaseHelper.updateFolder(selectedFolderDatabaseId, oldFolderNameString, newFolderNameString);
2645         } else if (!currentFolderIconRadioButton.isChecked() && newFolderNameString.equals(oldFolderNameString)) {  // Only the icon has changed.
2646             // Create the new folder icon Bitmap.
2647             Bitmap folderIconBitmap;
2648
2649             // Populate the new folder icon bitmap.
2650             if (defaultFolderIconRadioButton.isChecked()) {
2651                 // Get the default folder icon drawable.
2652                 Drawable folderIconDrawable = defaultFolderIconImageView.getDrawable();
2653
2654                 // Convert the folder icon drawable to a bitmap drawable.
2655                 BitmapDrawable folderIconBitmapDrawable = (BitmapDrawable) folderIconDrawable;
2656
2657                 // Convert the folder icon bitmap drawable to a bitmap.
2658                 folderIconBitmap = folderIconBitmapDrawable.getBitmap();
2659             } else {  // Use the `WebView` favorite icon.
2660                 // Copy the favorite icon bitmap to the folder icon bitmap.
2661                 folderIconBitmap = favoriteIconBitmap;
2662             }
2663
2664             // Create a folder icon byte array output stream.
2665             ByteArrayOutputStream newFolderIconByteArrayOutputStream = new ByteArrayOutputStream();
2666
2667             // Convert the folder icon bitmap to a byte array.  `0` is for lossless compression (the only option for a PNG).
2668             folderIconBitmap.compress(Bitmap.CompressFormat.PNG, 0, newFolderIconByteArrayOutputStream);
2669
2670             // Convert the folder icon byte array stream to a byte array.
2671             byte[] newFolderIconByteArray = newFolderIconByteArrayOutputStream.toByteArray();
2672
2673             // Update the folder icon in the database.
2674             bookmarksDatabaseHelper.updateFolder(selectedFolderDatabaseId, newFolderIconByteArray);
2675         } else {  // The folder icon and the name have changed.
2676             // Get the new folder icon `Bitmap`.
2677             Bitmap folderIconBitmap;
2678             if (defaultFolderIconRadioButton.isChecked()) {
2679                 // Get the default folder icon drawable.
2680                 Drawable folderIconDrawable = defaultFolderIconImageView.getDrawable();
2681
2682                 // Convert the folder icon drawable to a bitmap drawable.
2683                 BitmapDrawable folderIconBitmapDrawable = (BitmapDrawable) folderIconDrawable;
2684
2685                 // Convert the folder icon bitmap drawable to a bitmap.
2686                 folderIconBitmap = folderIconBitmapDrawable.getBitmap();
2687             } else {  // Use the `WebView` favorite icon.
2688                 // Copy the favorite icon bitmap to the folder icon bitmap.
2689                 folderIconBitmap = favoriteIconBitmap;
2690             }
2691
2692             // Create a folder icon byte array output stream.
2693             ByteArrayOutputStream newFolderIconByteArrayOutputStream = new ByteArrayOutputStream();
2694
2695             // Convert the folder icon bitmap to a byte array.  `0` is for lossless compression (the only option for a PNG).
2696             folderIconBitmap.compress(Bitmap.CompressFormat.PNG, 0, newFolderIconByteArrayOutputStream);
2697
2698             // Convert the folder icon byte array stream to a byte array.
2699             byte[] newFolderIconByteArray = newFolderIconByteArrayOutputStream.toByteArray();
2700
2701             // Update the folder name and icon in the database.
2702             bookmarksDatabaseHelper.updateFolder(selectedFolderDatabaseId, oldFolderNameString, newFolderNameString, newFolderIconByteArray);
2703         }
2704
2705         // Update the bookmarks cursor with the current contents of this folder.
2706         bookmarksCursor = bookmarksDatabaseHelper.getBookmarksByDisplayOrder(currentBookmarksFolder);
2707
2708         // Update the `ListView`.
2709         bookmarksCursorAdapter.changeCursor(bookmarksCursor);
2710     }
2711
2712     @Override
2713     public void onCloseDownloadLocationPermissionDialog(int downloadType) {
2714         switch (downloadType) {
2715             case DownloadLocationPermissionDialog.DOWNLOAD_FILE:
2716                 // Request the WRITE_EXTERNAL_STORAGE permission with a file request code.
2717                 ActivityCompat.requestPermissions(this, new String[] {Manifest.permission.WRITE_EXTERNAL_STORAGE}, DOWNLOAD_FILE_REQUEST_CODE);
2718                 break;
2719
2720             case DownloadLocationPermissionDialog.DOWNLOAD_IMAGE:
2721                 // Request the WRITE_EXTERNAL_STORAGE permission with an image request code.
2722                 ActivityCompat.requestPermissions(this, new String[] {Manifest.permission.WRITE_EXTERNAL_STORAGE}, DOWNLOAD_IMAGE_REQUEST_CODE);
2723                 break;
2724         }
2725     }
2726
2727     @Override
2728     public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
2729         // Get a handle for the fragment manager.
2730         FragmentManager fragmentManager = getSupportFragmentManager();
2731
2732         switch (requestCode) {
2733             case DOWNLOAD_FILE_REQUEST_CODE:
2734                 // Show the download file alert dialog.  When the dialog closes, the correct command will be used based on the permission status.
2735                 DialogFragment downloadFileDialogFragment = DownloadFileDialog.fromUrl(downloadUrl, downloadContentDisposition, downloadContentLength);
2736
2737                 // On API 23, displaying the fragment must be delayed or the app will crash.
2738                 if (Build.VERSION.SDK_INT == 23) {
2739                     new Handler().postDelayed(() -> downloadFileDialogFragment.show(fragmentManager, getString(R.string.download)), 500);
2740                 } else {
2741                     downloadFileDialogFragment.show(fragmentManager, getString(R.string.download));
2742                 }
2743
2744                 // Reset the download variables.
2745                 downloadUrl = "";
2746                 downloadContentDisposition = "";
2747                 downloadContentLength = 0;
2748                 break;
2749
2750             case DOWNLOAD_IMAGE_REQUEST_CODE:
2751                 // Show the download image alert dialog.  When the dialog closes, the correct command will be used based on the permission status.
2752                 DialogFragment downloadImageDialogFragment = DownloadImageDialog.imageUrl(downloadImageUrl);
2753
2754                 // On API 23, displaying the fragment must be delayed or the app will crash.
2755                 if (Build.VERSION.SDK_INT == 23) {
2756                     new Handler().postDelayed(() -> downloadImageDialogFragment.show(fragmentManager, getString(R.string.download)), 500);
2757                 } else {
2758                     downloadImageDialogFragment.show(fragmentManager, getString(R.string.download));
2759                 }
2760
2761                 // Reset the image URL variable.
2762                 downloadImageUrl = "";
2763                 break;
2764         }
2765     }
2766
2767     @Override
2768     public void onDownloadImage(DialogFragment dialogFragment, String imageUrl) {
2769         // Download the image if it has an HTTP or HTTPS URI.
2770         if (imageUrl.startsWith("http")) {
2771             // Get a handle for the system `DOWNLOAD_SERVICE`.
2772             DownloadManager downloadManager = (DownloadManager) getSystemService(DOWNLOAD_SERVICE);
2773
2774             // Parse `imageUrl`.
2775             DownloadManager.Request downloadRequest = new DownloadManager.Request(Uri.parse(imageUrl));
2776
2777             // Get a handle for the cookie manager.
2778             CookieManager cookieManager = CookieManager.getInstance();
2779
2780             // Pass cookies to download manager if cookies are enabled.  This is required to download images from websites that require a login.
2781             // Code contributed 2017 Hendrik Knackstedt.  Copyright assigned to Soren Stoutner <soren@stoutner.com>.
2782             if (cookieManager.acceptCookie()) {
2783                 // Get the cookies for `imageUrl`.
2784                 String cookies = cookieManager.getCookie(imageUrl);
2785
2786                 // Add the cookies to `downloadRequest`.  In the HTTP request header, cookies are named `Cookie`.
2787                 downloadRequest.addRequestHeader("Cookie", cookies);
2788             }
2789
2790             // Get the file name from the dialog fragment.
2791             EditText downloadImageNameEditText = dialogFragment.getDialog().findViewById(R.id.download_image_name);
2792             String imageName = downloadImageNameEditText.getText().toString();
2793
2794             // Specify the download location.
2795             if (ContextCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED) {  // External write permission granted.
2796                 // Download to the public download directory.
2797                 downloadRequest.setDestinationInExternalPublicDir(Environment.DIRECTORY_DOWNLOADS, imageName);
2798             } else {  // External write permission denied.
2799                 // Download to the app's external download directory.
2800                 downloadRequest.setDestinationInExternalFilesDir(this, Environment.DIRECTORY_DOWNLOADS, imageName);
2801             }
2802
2803             // Allow `MediaScanner` to index the download if it is a media file.
2804             downloadRequest.allowScanningByMediaScanner();
2805
2806             // Add the URL as the description for the download.
2807             downloadRequest.setDescription(imageUrl);
2808
2809             // Show the download notification after the download is completed.
2810             downloadRequest.setNotificationVisibility(DownloadManager.Request.VISIBILITY_VISIBLE_NOTIFY_COMPLETED);
2811
2812             // Remove the lint warning below that `downloadManager` might be `null`.
2813             assert downloadManager != null;
2814
2815             // Initiate the download.
2816             downloadManager.enqueue(downloadRequest);
2817         } else {  // The image is not an HTTP or HTTPS URI.
2818             Snackbar.make(currentWebView, R.string.cannot_download_image, Snackbar.LENGTH_INDEFINITE).show();
2819         }
2820     }
2821
2822     @Override
2823     public void onDownloadFile(DialogFragment dialogFragment, String downloadUrl) {
2824         // Download the file if it has an HTTP or HTTPS URI.
2825         if (downloadUrl.startsWith("http")) {
2826             // Get a handle for the system `DOWNLOAD_SERVICE`.
2827             DownloadManager downloadManager = (DownloadManager) getSystemService(DOWNLOAD_SERVICE);
2828
2829             // Parse `downloadUrl`.
2830             DownloadManager.Request downloadRequest = new DownloadManager.Request(Uri.parse(downloadUrl));
2831
2832             // Get a handle for the cookie manager.
2833             CookieManager cookieManager = CookieManager.getInstance();
2834
2835             // Pass cookies to download manager if cookies are enabled.  This is required to download files from websites that require a login.
2836             // Code contributed 2017 Hendrik Knackstedt.  Copyright assigned to Soren Stoutner <soren@stoutner.com>.
2837             if (cookieManager.acceptCookie()) {
2838                 // Get the cookies for `downloadUrl`.
2839                 String cookies = cookieManager.getCookie(downloadUrl);
2840
2841                 // Add the cookies to `downloadRequest`.  In the HTTP request header, cookies are named `Cookie`.
2842                 downloadRequest.addRequestHeader("Cookie", cookies);
2843             }
2844
2845             // Get the file name from the dialog fragment.
2846             EditText downloadFileNameEditText = dialogFragment.getDialog().findViewById(R.id.download_file_name);
2847             String fileName = downloadFileNameEditText.getText().toString();
2848
2849             // Specify the download location.
2850             if (ContextCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED) {  // External write permission granted.
2851                 // Download to the public download directory.
2852                 downloadRequest.setDestinationInExternalPublicDir(Environment.DIRECTORY_DOWNLOADS, fileName);
2853             } else {  // External write permission denied.
2854                 // Download to the app's external download directory.
2855                 downloadRequest.setDestinationInExternalFilesDir(this, Environment.DIRECTORY_DOWNLOADS, fileName);
2856             }
2857
2858             // Allow `MediaScanner` to index the download if it is a media file.
2859             downloadRequest.allowScanningByMediaScanner();
2860
2861             // Add the URL as the description for the download.
2862             downloadRequest.setDescription(downloadUrl);
2863
2864             // Show the download notification after the download is completed.
2865             downloadRequest.setNotificationVisibility(DownloadManager.Request.VISIBILITY_VISIBLE_NOTIFY_COMPLETED);
2866
2867             // Remove the lint warning below that `downloadManager` might be `null`.
2868             assert downloadManager != null;
2869
2870             // Initiate the download.
2871             downloadManager.enqueue(downloadRequest);
2872         } else {  // The download is not an HTTP or HTTPS URI.
2873             Snackbar.make(currentWebView, R.string.cannot_download_file, Snackbar.LENGTH_INDEFINITE).show();
2874         }
2875     }
2876
2877     // Override `onBackPressed` to handle the navigation drawer and and the WebView.
2878     @Override
2879     public void onBackPressed() {
2880         // Get a handle for the drawer layout and the tab layout.
2881         DrawerLayout drawerLayout = findViewById(R.id.drawerlayout);
2882         TabLayout tabLayout = findViewById(R.id.tablayout);
2883
2884         if (drawerLayout.isDrawerVisible(GravityCompat.START)) {  // The navigation drawer is open.
2885             // Close the navigation drawer.
2886             drawerLayout.closeDrawer(GravityCompat.START);
2887         } else if (drawerLayout.isDrawerVisible(GravityCompat.END)){  // The bookmarks drawer is open.
2888             if (currentBookmarksFolder.isEmpty()) {  // The home folder is displayed.
2889                 // close the bookmarks drawer.
2890                 drawerLayout.closeDrawer(GravityCompat.END);
2891             } else {  // A subfolder is displayed.
2892                 // Place the former parent folder in `currentFolder`.
2893                 currentBookmarksFolder = bookmarksDatabaseHelper.getParentFolderName(currentBookmarksFolder);
2894
2895                 // Load the new folder.
2896                 loadBookmarksFolder();
2897             }
2898         } else if (currentWebView.canGoBack()) {  // There is at least one item in the current WebView history.
2899             // Reset the current domain name so that navigation works if third-party requests are blocked.
2900             currentWebView.resetCurrentDomainName();
2901
2902             // Set navigating history so that the domain settings are applied when the new URL is loaded.
2903             currentWebView.setNavigatingHistory(true);
2904
2905             // Go back.
2906             currentWebView.goBack();
2907         } else if (tabLayout.getTabCount() > 1) {  // There are at least two tabs.
2908             // Close the current tab.
2909             closeCurrentTab();
2910         } else {  // There isn't anything to do in Privacy Browser.
2911             // Run the default commands.
2912             super.onBackPressed();
2913
2914             // Manually kill Privacy Browser.  Otherwise, it is glitchy when restarted.
2915             System.exit(0);
2916         }
2917     }
2918
2919     // Process the results of an upload file chooser.  Currently there is only one `startActivityForResult` in this activity, so the request code, used to differentiate them, is ignored.
2920     @Override
2921     public void onActivityResult(int requestCode, int resultCode, Intent data) {
2922         // File uploads only work on API >= 21.
2923         if (Build.VERSION.SDK_INT >= 21) {
2924             // Pass the file to the WebView.
2925             fileChooserCallback.onReceiveValue(WebChromeClient.FileChooserParams.parseResult(resultCode, data));
2926         }
2927     }
2928
2929     private void loadUrlFromTextBox() {
2930         // Get a handle for the URL edit text.
2931         EditText urlEditText = findViewById(R.id.url_edittext);
2932
2933         // Get the text from urlTextBox and convert it to a string.  trim() removes white spaces from the beginning and end of the string.
2934         String unformattedUrlString = urlEditText.getText().toString().trim();
2935
2936         // Initialize the formatted URL string.
2937         String url = "";
2938
2939         // Check to see if `unformattedUrlString` is a valid URL.  Otherwise, convert it into a search.
2940         if (unformattedUrlString.startsWith("content://")) {  // This is a Content URL.
2941             // Load the entire content URL.
2942             url = unformattedUrlString;
2943         } else if (Patterns.WEB_URL.matcher(unformattedUrlString).matches() || unformattedUrlString.startsWith("http://") || unformattedUrlString.startsWith("https://") ||
2944                 unformattedUrlString.startsWith("file://")) {  // This is a standard URL.
2945             // Add `https://` at the beginning if there is no protocol.  Otherwise the app will segfault.
2946             if (!unformattedUrlString.startsWith("http") && !unformattedUrlString.startsWith("file://") && !unformattedUrlString.startsWith("content://")) {
2947                 unformattedUrlString = "https://" + unformattedUrlString;
2948             }
2949
2950             // Initialize `unformattedUrl`.
2951             URL unformattedUrl = null;
2952
2953             // Convert `unformattedUrlString` to a `URL`, then to a `URI`, and then back to a `String`, which sanitizes the input and adds in any missing components.
2954             try {
2955                 unformattedUrl = new URL(unformattedUrlString);