Add a preference to control opening of intents in new tabs. https://redmine.stoutner...
[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.dialogs.AdConsentDialog;
119 import com.stoutner.privacybrowser.dialogs.CreateBookmarkDialog;
120 import com.stoutner.privacybrowser.dialogs.CreateBookmarkFolderDialog;
121 import com.stoutner.privacybrowser.dialogs.CreateHomeScreenShortcutDialog;
122 import com.stoutner.privacybrowser.dialogs.DownloadFileDialog;
123 import com.stoutner.privacybrowser.dialogs.DownloadImageDialog;
124 import com.stoutner.privacybrowser.dialogs.DownloadLocationPermissionDialog;
125 import com.stoutner.privacybrowser.dialogs.EditBookmarkDialog;
126 import com.stoutner.privacybrowser.dialogs.EditBookmarkFolderDialog;
127 import com.stoutner.privacybrowser.dialogs.HttpAuthenticationDialog;
128 import com.stoutner.privacybrowser.dialogs.SslCertificateErrorDialog;
129 import com.stoutner.privacybrowser.dialogs.UrlHistoryDialog;
130 import com.stoutner.privacybrowser.dialogs.ViewSslCertificateDialog;
131 import com.stoutner.privacybrowser.fragments.WebViewTabFragment;
132 import com.stoutner.privacybrowser.helpers.AdHelper;
133 import com.stoutner.privacybrowser.helpers.BlockListHelper;
134 import com.stoutner.privacybrowser.helpers.BookmarksDatabaseHelper;
135 import com.stoutner.privacybrowser.helpers.CheckPinnedMismatchHelper;
136 import com.stoutner.privacybrowser.helpers.DomainsDatabaseHelper;
137 import com.stoutner.privacybrowser.helpers.OrbotProxyHelper;
138 import com.stoutner.privacybrowser.views.NestedScrollWebView;
139
140 import java.io.ByteArrayInputStream;
141 import java.io.ByteArrayOutputStream;
142 import java.io.File;
143 import java.io.IOException;
144 import java.io.UnsupportedEncodingException;
145 import java.net.MalformedURLException;
146 import java.net.URL;
147 import java.net.URLDecoder;
148 import java.net.URLEncoder;
149 import java.util.ArrayList;
150 import java.util.Date;
151 import java.util.HashMap;
152 import java.util.HashSet;
153 import java.util.List;
154 import java.util.Map;
155 import java.util.Set;
156
157 // AppCompatActivity from android.support.v7.app.AppCompatActivity must be used to have access to the SupportActionBar until the minimum API is >= 21.
158 public class MainWebViewActivity extends AppCompatActivity implements CreateBookmarkDialog.CreateBookmarkListener, CreateBookmarkFolderDialog.CreateBookmarkFolderListener,
159         DownloadFileDialog.DownloadFileListener, DownloadImageDialog.DownloadImageListener, DownloadLocationPermissionDialog.DownloadLocationPermissionDialogListener, EditBookmarkDialog.EditBookmarkListener,
160         EditBookmarkFolderDialog.EditBookmarkFolderListener, NavigationView.OnNavigationItemSelectedListener, WebViewTabFragment.NewTabListener {
161
162     // `orbotStatus` is public static so it can be accessed from `OrbotProxyHelper`.  It is also used in `onCreate()`, `onResume()`, and `applyProxyThroughOrbot()`.
163     public static String orbotStatus;
164
165     // The WebView pager adapter is accessed from `HttpAuthenticationDialog`, `PinnedMismatchDialog`, and `SslCertificateErrorDialog`.  It is also used in `onCreate()`, `onResume()`, and `addTab()`.
166     public static WebViewPagerAdapter webViewPagerAdapter;
167
168     // The load URL on restart variables are public static so they can be accessed from `BookmarksActivity`.  They are used in `onRestart()`.
169     public static boolean loadUrlOnRestart;
170     public static String urlToLoadOnRestart;
171
172     // `restartFromBookmarksActivity` is public static so it can be accessed from `BookmarksActivity`.  It is also used in `onRestart()`.
173     public static boolean restartFromBookmarksActivity;
174
175     // `currentBookmarksFolder` is public static so it can be accessed from `BookmarksActivity`.  It is also used in `onCreate()`, `onBackPressed()`, `onCreateBookmark()`, `onCreateBookmarkFolder()`,
176     // `onSaveEditBookmark()`, `onSaveEditBookmarkFolder()`, and `loadBookmarksFolder()`.
177     public static String currentBookmarksFolder;
178
179     // The user agent constants are public static so they can be accessed from `SettingsFragment`, `DomainsActivity`, and `DomainSettingsFragment`.
180     public final static int UNRECOGNIZED_USER_AGENT = -1;
181     public final static int SETTINGS_WEBVIEW_DEFAULT_USER_AGENT = 1;
182     public final static int SETTINGS_CUSTOM_USER_AGENT = 12;
183     public final static int DOMAINS_SYSTEM_DEFAULT_USER_AGENT = 0;
184     public final static int DOMAINS_WEBVIEW_DEFAULT_USER_AGENT = 2;
185     public final static int DOMAINS_CUSTOM_USER_AGENT = 13;
186
187
188
189     // The current WebView is used in `onCreate()`, `onPrepareOptionsMenu()`, `onOptionsItemSelected()`, `onNavigationItemSelected()`, `onRestart()`, `onCreateContextMenu()`, `findPreviousOnPage()`,
190     // `findNextOnPage()`, `closeFindOnPage()`, `loadUrlFromTextBox()`, `onSslMismatchBack()`, `applyProxyThroughOrbot()`, and `applyDomainSettings()`.
191     private NestedScrollWebView currentWebView;
192
193     // `customHeader` is used in `onCreate()`, `onOptionsItemSelected()`, `onCreateContextMenu()`, and `loadUrl()`.
194     private final Map<String, String> customHeaders = new HashMap<>();
195
196     // The search URL is set in `applyProxyThroughOrbot()` and used in `onCreate()`, `onNewIntent()`, `loadURLFromTextBox()`, and `initializeWebView()`.
197     private String searchURL;
198
199     // The options menu is set in `onCreateOptionsMenu()` and used in `onOptionsItemSelected()`, `updatePrivacyIcons()`, and `initializeWebView()`.
200     private Menu optionsMenu;
201
202     // The blocklists are populated in `onCreate()` and accessed from `initializeWebView()`.
203     private ArrayList<List<String[]>> easyList;
204     private ArrayList<List<String[]>> easyPrivacy;
205     private ArrayList<List<String[]>> fanboysAnnoyanceList;
206     private ArrayList<List<String[]>> fanboysSocialList;
207     private ArrayList<List<String[]>> ultraPrivacy;
208
209     // `webViewDefaultUserAgent` is used in `onCreate()` and `onPrepareOptionsMenu()`.
210     private String webViewDefaultUserAgent;
211
212     // `proxyThroughOrbot` is used in `onRestart()`, `onOptionsItemSelected()`, `applyAppSettings()`, and `applyProxyThroughOrbot()`.
213     private boolean proxyThroughOrbot;
214
215     // The incognito mode is set in `applyAppSettings()` and used in `initializeWebView()`.
216     private boolean incognitoModeEnabled;
217
218     // The full screen browsing mode tracker is set it `applyAppSettings()` and used in `initializeWebView()`.
219     private boolean fullScreenBrowsingModeEnabled;
220
221     // `inFullScreenBrowsingMode` is used in `onCreate()`, `onConfigurationChanged()`, and `applyAppSettings()`.
222     private boolean inFullScreenBrowsingMode;
223
224     // The app bar trackers are set in `applyAppSettings()` and used in `initializeWebView()`.
225     private boolean hideAppBar;
226     private boolean scrollAppBar;
227
228     // `reapplyDomainSettingsOnRestart` is used in `onCreate()`, `onOptionsItemSelected()`, `onNavigationItemSelected()`, `onRestart()`, and `onAddDomain()`, .
229     private boolean reapplyDomainSettingsOnRestart;
230
231     // `reapplyAppSettingsOnRestart` is used in `onNavigationItemSelected()` and `onRestart()`.
232     private boolean reapplyAppSettingsOnRestart;
233
234     // `displayingFullScreenVideo` is used in `onCreate()` and `onResume()`.
235     private boolean displayingFullScreenVideo;
236
237     // `orbotStatusBroadcastReceiver` is used in `onCreate()` and `onDestroy()`.
238     private BroadcastReceiver orbotStatusBroadcastReceiver;
239
240     // `waitingForOrbot` is used in `onCreate()`, `onResume()`, and `applyProxyThroughOrbot()`.
241     private boolean waitingForOrbot;
242
243     // The action bar drawer toggle is initialized in `onCreate()` and used in `onResume()`.
244     private ActionBarDrawerToggle actionBarDrawerToggle;
245
246     // The color spans are used in `onCreate()` and `highlightUrlText()`.
247     private ForegroundColorSpan redColorSpan;
248     private ForegroundColorSpan initialGrayColorSpan;
249     private ForegroundColorSpan finalGrayColorSpan;
250
251     // The drawer header padding variables are used in `onCreate()` and `onConfigurationChanged()`.
252     private int drawerHeaderPaddingLeftAndRight;
253     private int drawerHeaderPaddingTop;
254     private int drawerHeaderPaddingBottom;
255
256     // `bookmarksDatabaseHelper` is used in `onCreate()`, `onDestroy`, `onOptionsItemSelected()`, `onCreateBookmark()`, `onCreateBookmarkFolder()`, `onSaveEditBookmark()`, `onSaveEditBookmarkFolder()`,
257     // and `loadBookmarksFolder()`.
258     private BookmarksDatabaseHelper bookmarksDatabaseHelper;
259
260     // `bookmarksCursor` is used in `onDestroy()`, `onOptionsItemSelected()`, `onCreateBookmark()`, `onCreateBookmarkFolder()`, `onSaveEditBookmark()`, `onSaveEditBookmarkFolder()`, and `loadBookmarksFolder()`.
261     private Cursor bookmarksCursor;
262
263     // `bookmarksCursorAdapter` is used in `onCreateBookmark()`, `onCreateBookmarkFolder()` `onSaveEditBookmark()`, `onSaveEditBookmarkFolder()`, and `loadBookmarksFolder()`.
264     private CursorAdapter bookmarksCursorAdapter;
265
266     // `oldFolderNameString` is used in `onCreate()` and `onSaveEditBookmarkFolder()`.
267     private String oldFolderNameString;
268
269     // `fileChooserCallback` is used in `onCreate()` and `onActivityResult()`.
270     private ValueCallback<Uri[]> fileChooserCallback;
271
272     // The default progress view offsets are set in `onCreate()` and used in `initializeWebView()`.
273     private int defaultProgressViewStartOffset;
274     private int defaultProgressViewEndOffset;
275
276     // The swipe refresh layout top padding is used when exiting full screen browsing mode.  It is used in an inner class in `initializeWebView()`.
277     private int swipeRefreshLayoutPaddingTop;
278
279     // The download strings are used in `onCreate()`, `onRequestPermissionResult()` and `initializeWebView()`.
280     private String downloadUrl;
281     private String downloadContentDisposition;
282     private long downloadContentLength;
283
284     // `downloadImageUrl` is used in `onCreateContextMenu()` and `onRequestPermissionResult()`.
285     private String downloadImageUrl;
286
287     // The request codes are used in `onCreate()`, `onCreateContextMenu()`, `onCloseDownloadLocationPermissionDialog()`, `onRequestPermissionResult()`, and `initializeWebView()`.
288     private final int DOWNLOAD_FILE_REQUEST_CODE = 1;
289     private final int DOWNLOAD_IMAGE_REQUEST_CODE = 2;
290
291     @Override
292     // Remove the warning about needing to override `performClick()` when using an `OnTouchListener` with `WebView`.
293     @SuppressLint("ClickableViewAccessibility")
294     protected void onCreate(Bundle savedInstanceState) {
295         // Get a handle for the shared preferences.
296         SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(this);
297
298         // Get the theme and screenshot preferences.
299         boolean darkTheme = sharedPreferences.getBoolean("dark_theme", false);
300         boolean allowScreenshots = sharedPreferences.getBoolean("allow_screenshots", false);
301
302         // Disable screenshots if not allowed.
303         if (!allowScreenshots) {
304             getWindow().addFlags(WindowManager.LayoutParams.FLAG_SECURE);
305         }
306
307         // Set the activity theme.
308         if (darkTheme) {
309             setTheme(R.style.PrivacyBrowserDark);
310         } else {
311             setTheme(R.style.PrivacyBrowserLight);
312         }
313
314         // Run the default commands.
315         super.onCreate(savedInstanceState);
316
317         // Set the content view.
318         setContentView(R.layout.main_framelayout);
319
320         // Get a handle for the input method.
321         InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
322
323         // Remove the lint warning below that the input method manager might be null.
324         assert inputMethodManager != null;
325
326         // Get a handle for the toolbar.
327         Toolbar toolbar = findViewById(R.id.toolbar);
328
329         // Set the action bar.  `SupportActionBar` must be used until the minimum API is >= 21.
330         setSupportActionBar(toolbar);
331
332         // Get a handle for the action bar.
333         ActionBar actionBar = getSupportActionBar();
334
335         // This is needed to get rid of the Android Studio warning that the action bar might be null.
336         assert actionBar != null;
337
338         // Add the custom layout, which shows the URL text bar.
339         actionBar.setCustomView(R.layout.url_app_bar);
340         actionBar.setDisplayOptions(ActionBar.DISPLAY_SHOW_CUSTOM);
341
342         // Initialize the foreground color spans for highlighting the URLs.  We have to use the deprecated `getColor()` until API >= 23.
343         redColorSpan = new ForegroundColorSpan(getResources().getColor(R.color.red_a700));
344         initialGrayColorSpan = new ForegroundColorSpan(getResources().getColor(R.color.gray_500));
345         finalGrayColorSpan = new ForegroundColorSpan(getResources().getColor(R.color.gray_500));
346
347         // Get handles for the URL views.
348         EditText urlEditText = findViewById(R.id.url_edittext);
349
350         // Remove the formatting from `urlTextBar` when the user is editing the text.
351         urlEditText.setOnFocusChangeListener((View v, boolean hasFocus) -> {
352             if (hasFocus) {  // The user is editing the URL text box.
353                 // Remove the highlighting.
354                 urlEditText.getText().removeSpan(redColorSpan);
355                 urlEditText.getText().removeSpan(initialGrayColorSpan);
356                 urlEditText.getText().removeSpan(finalGrayColorSpan);
357             } else {  // The user has stopped editing the URL text box.
358                 // Move to the beginning of the string.
359                 urlEditText.setSelection(0);
360
361                 // Reapply the highlighting.
362                 highlightUrlText();
363             }
364         });
365
366         // Set the go button on the keyboard to load the URL in `urlTextBox`.
367         urlEditText.setOnKeyListener((View v, int keyCode, KeyEvent event) -> {
368             // If the event is a key-down event on the `enter` button, load the URL.
369             if ((event.getAction() == KeyEvent.ACTION_DOWN) && (keyCode == KeyEvent.KEYCODE_ENTER)) {
370                 // Load the URL into the mainWebView and consume the event.
371                 loadUrlFromTextBox();
372
373                 // If the enter key was pressed, consume the event.
374                 return true;
375             } else {
376                 // If any other key was pressed, do not consume the event.
377                 return false;
378             }
379         });
380
381         // Initialize the Orbot status and the waiting for Orbot trackers.
382         orbotStatus = "unknown";
383         waitingForOrbot = false;
384
385         // Create an Orbot status `BroadcastReceiver`.
386         orbotStatusBroadcastReceiver = new BroadcastReceiver() {
387             @Override
388             public void onReceive(Context context, Intent intent) {
389                 // Store the content of the status message in `orbotStatus`.
390                 orbotStatus = intent.getStringExtra("org.torproject.android.intent.extra.STATUS");
391
392                 // If Privacy Browser is waiting on Orbot, load the website now that Orbot is connected.
393                 if (orbotStatus.equals("ON") && waitingForOrbot) {
394                     // Reset the waiting for Orbot status.
395                     waitingForOrbot = false;
396
397                     // Get the intent that started the app.
398                     Intent launchingIntent = getIntent();
399
400                     // Get the information from the intent.
401                     String launchingIntentAction = launchingIntent.getAction();
402                     Uri launchingIntentUriData = launchingIntent.getData();
403
404                     // If the intent action is a web search, perform the search.
405                     if ((launchingIntentAction != null) && launchingIntentAction.equals(Intent.ACTION_WEB_SEARCH)) {
406                         // Create an encoded URL string.
407                         String encodedUrlString;
408
409                         // Sanitize the search input and convert it to a search.
410                         try {
411                             encodedUrlString = URLEncoder.encode(launchingIntent.getStringExtra(SearchManager.QUERY), "UTF-8");
412                         } catch (UnsupportedEncodingException exception) {
413                             encodedUrlString = "";
414                         }
415
416                         // Load the completed search URL.
417                         loadUrl(searchURL + encodedUrlString);
418                     } else if (launchingIntentUriData != null){  // Check to see if the intent contains a new URL.
419                         // Load the URL from the intent.
420                         loadUrl(launchingIntentUriData.toString());
421                     } else {  // The is no URL in the intent.
422                         // Select the homepage based on the proxy through Orbot status.
423                         if (proxyThroughOrbot) {
424                             // Load the Tor homepage.
425                             loadUrl(sharedPreferences.getString("tor_homepage", getString(R.string.tor_homepage_default_value)));
426                         } else {
427                             // Load the normal homepage.
428                             loadUrl(sharedPreferences.getString("homepage", getString(R.string.homepage_default_value)));
429                         }
430                     }
431                 }
432             }
433         };
434
435         // Register `orbotStatusBroadcastReceiver` on `this` context.
436         this.registerReceiver(orbotStatusBroadcastReceiver, new IntentFilter("org.torproject.android.intent.action.STATUS"));
437
438         // Instantiate the blocklist helper.
439         BlockListHelper blockListHelper = new BlockListHelper();
440
441         // Parse the block lists.
442         easyList = blockListHelper.parseBlockList(getAssets(), "blocklists/easylist.txt");
443         easyPrivacy = blockListHelper.parseBlockList(getAssets(), "blocklists/easyprivacy.txt");
444         fanboysAnnoyanceList = blockListHelper.parseBlockList(getAssets(), "blocklists/fanboy-annoyance.txt");
445         fanboysSocialList = blockListHelper.parseBlockList(getAssets(), "blocklists/fanboy-social.txt");
446         ultraPrivacy = blockListHelper.parseBlockList(getAssets(), "blocklists/ultraprivacy.txt");
447
448         // Get handles for views that need to be modified.
449         DrawerLayout drawerLayout = findViewById(R.id.drawerlayout);
450         NavigationView navigationView = findViewById(R.id.navigationview);
451         TabLayout tabLayout = findViewById(R.id.tablayout);
452         SwipeRefreshLayout swipeRefreshLayout = findViewById(R.id.swiperefreshlayout);
453         ViewPager webViewPager = findViewById(R.id.webviewpager);
454         ListView bookmarksListView = findViewById(R.id.bookmarks_drawer_listview);
455         FloatingActionButton launchBookmarksActivityFab = findViewById(R.id.launch_bookmarks_activity_fab);
456         FloatingActionButton createBookmarkFolderFab = findViewById(R.id.create_bookmark_folder_fab);
457         FloatingActionButton createBookmarkFab = findViewById(R.id.create_bookmark_fab);
458         EditText findOnPageEditText = findViewById(R.id.find_on_page_edittext);
459
460         // Listen for touches on the navigation menu.
461         navigationView.setNavigationItemSelectedListener(this);
462
463         // Get handles for the navigation menu and the back and forward menu items.  The menu is zero-based.
464         Menu navigationMenu = navigationView.getMenu();
465         MenuItem navigationCloseTabMenuItem = navigationMenu.getItem(0);
466         MenuItem navigationBackMenuItem = navigationMenu.getItem(3);
467         MenuItem navigationForwardMenuItem = navigationMenu.getItem(4);
468         MenuItem navigationHistoryMenuItem = navigationMenu.getItem(5);
469         MenuItem navigationRequestsMenuItem = navigationMenu.getItem(6);
470
471         // Initialize the web view pager adapter.
472         webViewPagerAdapter = new WebViewPagerAdapter(getSupportFragmentManager());
473
474         // Set the pager adapter on the web view pager.
475         webViewPager.setAdapter(webViewPagerAdapter);
476
477         // Store up to 100 tabs in memory.
478         webViewPager.setOffscreenPageLimit(100);
479
480         // Update the web view pager every time a tab is modified.
481         webViewPager.addOnPageChangeListener(new ViewPager.OnPageChangeListener() {
482             @Override
483             public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) {
484                 // Do nothing.
485             }
486
487             @Override
488             public void onPageSelected(int position) {
489                 // Close the find on page bar if it is open.
490                 closeFindOnPage(null);
491
492                 // Set the current WebView.
493                 setCurrentWebView(position);
494
495                 // 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.
496                 if (tabLayout.getSelectedTabPosition() != position) {
497                     // Create a handler to select the tab.
498                     Handler selectTabHandler = new Handler();
499
500                     // Create a runnable select the new tab.
501                     Runnable selectTabRunnable = () -> {
502                         // Get a handle for the tab.
503                         TabLayout.Tab tab = tabLayout.getTabAt(position);
504
505                         // Assert that the tab is not null.
506                         assert tab != null;
507
508                         // Select the tab.
509                         tab.select();
510                     };
511
512                     // Select the tab layout after 100 milliseconds, which leaves enough time for a new tab to be created.
513                     selectTabHandler.postDelayed(selectTabRunnable, 100);
514                 }
515             }
516
517             @Override
518             public void onPageScrollStateChanged(int state) {
519                 // Do nothing.
520             }
521         });
522
523         // Display the View SSL Certificate dialog when the currently selected tab is reselected.
524         tabLayout.addOnTabSelectedListener(new TabLayout.OnTabSelectedListener() {
525             @Override
526             public void onTabSelected(TabLayout.Tab tab) {
527                 // Select the same page in the view pager.
528                 webViewPager.setCurrentItem(tab.getPosition());
529             }
530
531             @Override
532             public void onTabUnselected(TabLayout.Tab tab) {
533                 // Do nothing.
534             }
535
536             @Override
537             public void onTabReselected(TabLayout.Tab tab) {
538                 // Instantiate the View SSL Certificate dialog.
539                 DialogFragment viewSslCertificateDialogFragment = ViewSslCertificateDialog.displayDialog(currentWebView.getWebViewFragmentId());
540
541                 // Display the View SSL Certificate dialog.
542                 viewSslCertificateDialogFragment.show(getSupportFragmentManager(), getString(R.string.view_ssl_certificate));
543             }
544         });
545
546         // Add the first tab.
547         addTab(null);
548
549         // 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.
550         // The deprecated `getResources().getDrawable()` must be used until the minimum API >= 21 and and `getResources().getColor()` must be used until the minimum API >= 23.
551         if (darkTheme) {
552             launchBookmarksActivityFab.setImageDrawable(getResources().getDrawable(R.drawable.bookmarks_dark));
553             createBookmarkFolderFab.setImageDrawable(getResources().getDrawable(R.drawable.create_folder_dark));
554             createBookmarkFab.setImageDrawable(getResources().getDrawable(R.drawable.create_bookmark_dark));
555             bookmarksListView.setBackgroundColor(getResources().getColor(R.color.gray_850));
556         } else {
557             launchBookmarksActivityFab.setImageDrawable(getResources().getDrawable(R.drawable.bookmarks_light));
558             createBookmarkFolderFab.setImageDrawable(getResources().getDrawable(R.drawable.create_folder_light));
559             createBookmarkFab.setImageDrawable(getResources().getDrawable(R.drawable.create_bookmark_light));
560             bookmarksListView.setBackgroundColor(getResources().getColor(R.color.white));
561         }
562
563         // Set the launch bookmarks activity FAB to launch the bookmarks activity.
564         launchBookmarksActivityFab.setOnClickListener(v -> {
565             // Get a copy of the favorite icon bitmap.
566             Bitmap favoriteIconBitmap = currentWebView.getFavoriteOrDefaultIcon();
567
568             // Create a favorite icon byte array output stream.
569             ByteArrayOutputStream favoriteIconByteArrayOutputStream = new ByteArrayOutputStream();
570
571             // Convert the favorite icon bitmap to a byte array.  `0` is for lossless compression (the only option for a PNG).
572             favoriteIconBitmap.compress(Bitmap.CompressFormat.PNG, 0, favoriteIconByteArrayOutputStream);
573
574             // Convert the favorite icon byte array stream to a byte array.
575             byte[] favoriteIconByteArray = favoriteIconByteArrayOutputStream.toByteArray();
576
577             // Create an intent to launch the bookmarks activity.
578             Intent bookmarksIntent = new Intent(getApplicationContext(), BookmarksActivity.class);
579
580             // Add the extra information to the intent.
581             bookmarksIntent.putExtra("current_url", currentWebView.getUrl());
582             bookmarksIntent.putExtra("current_title", currentWebView.getTitle());
583             bookmarksIntent.putExtra("current_folder", currentBookmarksFolder);
584             bookmarksIntent.putExtra("favorite_icon_byte_array", favoriteIconByteArray);
585
586             // Make it so.
587             startActivity(bookmarksIntent);
588         });
589
590         // Set the create new bookmark folder FAB to display an alert dialog.
591         createBookmarkFolderFab.setOnClickListener(v -> {
592             // Create a create bookmark folder dialog.
593             DialogFragment createBookmarkFolderDialog = CreateBookmarkFolderDialog.createBookmarkFolder(currentWebView.getFavoriteOrDefaultIcon());
594
595             // Show the create bookmark folder dialog.
596             createBookmarkFolderDialog.show(getSupportFragmentManager(), getString(R.string.create_folder));
597         });
598
599         // Set the create new bookmark FAB to display an alert dialog.
600         createBookmarkFab.setOnClickListener(view -> {
601             // Instantiate the create bookmark dialog.
602             DialogFragment createBookmarkDialog = CreateBookmarkDialog.createBookmark(currentWebView.getUrl(), currentWebView.getTitle(), currentWebView.getFavoriteOrDefaultIcon());
603
604             // Display the create bookmark dialog.
605             createBookmarkDialog.show(getSupportFragmentManager(), getString(R.string.create_bookmark));
606         });
607
608         // Search for the string on the page whenever a character changes in the `findOnPageEditText`.
609         findOnPageEditText.addTextChangedListener(new TextWatcher() {
610             @Override
611             public void beforeTextChanged(CharSequence s, int start, int count, int after) {
612                 // Do nothing.
613             }
614
615             @Override
616             public void onTextChanged(CharSequence s, int start, int before, int count) {
617                 // Do nothing.
618             }
619
620             @Override
621             public void afterTextChanged(Editable s) {
622                 // 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.
623                 if (currentWebView != null) {
624                     currentWebView.findAllAsync(findOnPageEditText.getText().toString());
625                 }
626             }
627         });
628
629         // Set the `check mark` button for the `findOnPageEditText` keyboard to close the soft keyboard.
630         findOnPageEditText.setOnKeyListener((v, keyCode, event) -> {
631             if ((event.getAction() == KeyEvent.ACTION_DOWN) && (keyCode == KeyEvent.KEYCODE_ENTER)) {  // The `enter` key was pressed.
632                 // Hide the soft keyboard.
633                 inputMethodManager.hideSoftInputFromWindow(currentWebView.getWindowToken(), 0);
634
635                 // Consume the event.
636                 return true;
637             } else {  // A different key was pressed.
638                 // Do not consume the event.
639                 return false;
640             }
641         });
642
643         // Implement swipe to refresh.
644         swipeRefreshLayout.setOnRefreshListener(() -> currentWebView.reload());
645
646         // Store the default progress view offsets for use later in `initializeWebView()`.
647         defaultProgressViewStartOffset = swipeRefreshLayout.getProgressViewStartOffset();
648         defaultProgressViewEndOffset = swipeRefreshLayout.getProgressViewEndOffset();
649
650         // Set the swipe to refresh color according to the theme.
651         if (darkTheme) {
652             swipeRefreshLayout.setColorSchemeResources(R.color.blue_800);
653             swipeRefreshLayout.setProgressBackgroundColorSchemeResource(R.color.gray_850);
654         } else {
655             swipeRefreshLayout.setColorSchemeResources(R.color.blue_500);
656         }
657
658         // `DrawerTitle` identifies the `DrawerLayouts` in accessibility mode.
659         drawerLayout.setDrawerTitle(GravityCompat.START, getString(R.string.navigation_drawer));
660         drawerLayout.setDrawerTitle(GravityCompat.END, getString(R.string.bookmarks));
661
662         // Initialize the bookmarks database helper.  The `0` specifies a database version, but that is ignored and set instead using a constant in `BookmarksDatabaseHelper`.
663         bookmarksDatabaseHelper = new BookmarksDatabaseHelper(this, null, null, 0);
664
665         // Initialize `currentBookmarksFolder`.  `""` is the home folder in the database.
666         currentBookmarksFolder = "";
667
668         // Load the home folder, which is `""` in the database.
669         loadBookmarksFolder();
670
671         bookmarksListView.setOnItemClickListener((parent, view, position, id) -> {
672             // Convert the id from long to int to match the format of the bookmarks database.
673             int databaseID = (int) id;
674
675             // Get the bookmark cursor for this ID and move it to the first row.
676             Cursor bookmarkCursor = bookmarksDatabaseHelper.getBookmark(databaseID);
677             bookmarkCursor.moveToFirst();
678
679             // Act upon the bookmark according to the type.
680             if (bookmarkCursor.getInt(bookmarkCursor.getColumnIndex(BookmarksDatabaseHelper.IS_FOLDER)) == 1) {  // The selected bookmark is a folder.
681                 // Store the new folder name in `currentBookmarksFolder`.
682                 currentBookmarksFolder = bookmarkCursor.getString(bookmarkCursor.getColumnIndex(BookmarksDatabaseHelper.BOOKMARK_NAME));
683
684                 // Load the new folder.
685                 loadBookmarksFolder();
686             } else {  // The selected bookmark is not a folder.
687                 // Load the bookmark URL.
688                 loadUrl(bookmarkCursor.getString(bookmarkCursor.getColumnIndex(BookmarksDatabaseHelper.BOOKMARK_URL)));
689
690                 // Close the bookmarks drawer.
691                 drawerLayout.closeDrawer(GravityCompat.END);
692             }
693
694             // Close the `Cursor`.
695             bookmarkCursor.close();
696         });
697
698         bookmarksListView.setOnItemLongClickListener((parent, view, position, id) -> {
699             // Convert the database ID from `long` to `int`.
700             int databaseId = (int) id;
701
702             // Find out if the selected bookmark is a folder.
703             boolean isFolder = bookmarksDatabaseHelper.isFolder(databaseId);
704
705             if (isFolder) {
706                 // Save the current folder name, which is used in `onSaveEditBookmarkFolder()`.
707                 oldFolderNameString = bookmarksCursor.getString(bookmarksCursor.getColumnIndex(BookmarksDatabaseHelper.BOOKMARK_NAME));
708
709                 // Show the edit bookmark folder `AlertDialog` and name the instance `@string/edit_folder`.
710                 DialogFragment editBookmarkFolderDialog = EditBookmarkFolderDialog.folderDatabaseId(databaseId, currentWebView.getFavoriteOrDefaultIcon());
711                 editBookmarkFolderDialog.show(getSupportFragmentManager(), getString(R.string.edit_folder));
712             } else {
713                 // Show the edit bookmark `AlertDialog` and name the instance `@string/edit_bookmark`.
714                 DialogFragment editBookmarkDialog = EditBookmarkDialog.bookmarkDatabaseId(databaseId, currentWebView.getFavoriteOrDefaultIcon());
715                 editBookmarkDialog.show(getSupportFragmentManager(), getString(R.string.edit_bookmark));
716             }
717
718             // Consume the event.
719             return true;
720         });
721
722         // Get the status bar pixel size.
723         int statusBarResourceId = getResources().getIdentifier("status_bar_height", "dimen", "android");
724         int statusBarPixelSize = getResources().getDimensionPixelSize(statusBarResourceId);
725
726         // Get the resource density.
727         float screenDensity = getResources().getDisplayMetrics().density;
728
729         // Calculate the drawer header padding.  This is used to move the text in the drawer headers below any cutouts.
730         drawerHeaderPaddingLeftAndRight = (int) (15 * screenDensity);
731         drawerHeaderPaddingTop = statusBarPixelSize + (int) (4 * screenDensity);
732         drawerHeaderPaddingBottom = (int) (8 * screenDensity);
733
734         // The drawer listener is used to update the navigation menu.`
735         drawerLayout.addDrawerListener(new DrawerLayout.DrawerListener() {
736             @Override
737             public void onDrawerSlide(@NonNull View drawerView, float slideOffset) {
738             }
739
740             @Override
741             public void onDrawerOpened(@NonNull View drawerView) {
742             }
743
744             @Override
745             public void onDrawerClosed(@NonNull View drawerView) {
746             }
747
748             @Override
749             public void onDrawerStateChanged(int newState) {
750                 if ((newState == DrawerLayout.STATE_SETTLING) || (newState == DrawerLayout.STATE_DRAGGING)) {  // A drawer is opening or closing.
751                     // Get handles for the drawer headers.
752                     TextView navigationHeaderTextView = findViewById(R.id.navigationText);
753                     TextView bookmarksHeaderTextView = findViewById(R.id.bookmarks_title_textview);
754
755                     // 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.
756                     if (navigationHeaderTextView != null) {
757                         navigationHeaderTextView.setPadding(drawerHeaderPaddingLeftAndRight, drawerHeaderPaddingTop, drawerHeaderPaddingLeftAndRight, drawerHeaderPaddingBottom);
758                     }
759
760                     // 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.
761                     if (bookmarksHeaderTextView != null) {
762                         bookmarksHeaderTextView.setPadding(drawerHeaderPaddingLeftAndRight, drawerHeaderPaddingTop, drawerHeaderPaddingLeftAndRight, drawerHeaderPaddingBottom);
763                     }
764
765                     // Update the navigation menu items.
766                     navigationCloseTabMenuItem.setEnabled(tabLayout.getTabCount() > 1);
767                     navigationBackMenuItem.setEnabled(currentWebView.canGoBack());
768                     navigationForwardMenuItem.setEnabled(currentWebView.canGoForward());
769                     navigationHistoryMenuItem.setEnabled((currentWebView.canGoBack() || currentWebView.canGoForward()));
770                     navigationRequestsMenuItem.setTitle(getString(R.string.requests) + " - " + currentWebView.getRequestsCount(NestedScrollWebView.BLOCKED_REQUESTS));
771
772                     // Hide the keyboard (if displayed).
773                     inputMethodManager.hideSoftInputFromWindow(currentWebView.getWindowToken(), 0);
774
775                     // 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.
776                     urlEditText.clearFocus();
777                     currentWebView.clearFocus();
778                 }
779             }
780         });
781
782         // Create the hamburger icon at the start of the AppBar.
783         actionBarDrawerToggle = new ActionBarDrawerToggle(this, drawerLayout, toolbar, R.string.open_navigation_drawer, R.string.close_navigation_drawer);
784
785         // 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).
786         customHeaders.put("X-Requested-With", "");
787
788         // Initialize the default preference values the first time the program is run.  `false` keeps this command from resetting any current preferences back to default.
789         PreferenceManager.setDefaultValues(this, R.xml.preferences, false);
790
791         // Inflate a bare WebView to get the default user agent.  It is not used to render content on the screen.
792         @SuppressLint("InflateParams") View webViewLayout = getLayoutInflater().inflate(R.layout.bare_webview, null, false);
793
794         // Get a handle for the WebView.
795         WebView bareWebView = webViewLayout.findViewById(R.id.bare_webview);
796
797         // Store the default user agent.
798         webViewDefaultUserAgent = bareWebView.getSettings().getUserAgentString();
799
800         // Destroy the bare WebView.
801         bareWebView.destroy();
802     }
803
804     @Override
805     protected void onNewIntent(Intent intent) {
806         // Get the information from the intent.
807         String intentAction = intent.getAction();
808         Uri intentUriData = intent.getData();
809
810         // Only process the URI if it contains data.  If the user pressed the desktop icon after the app was already running the URI will be null.
811         if (intentUriData != null) {
812             // Sets the new intent as the activity intent, which replaces the one that originally started the app.
813             setIntent(intent);
814
815             // Get the shared preferences.
816             SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(this);
817
818             if (sharedPreferences.getBoolean("open_intents_in_new_tab", true)) {
819                 // Add a new tab.
820                 addTab(null);
821             }
822
823             // Create a URL string.
824             String url;
825
826             // If the intent action is a web search, perform the search.
827             if ((intentAction != null) && intentAction.equals(Intent.ACTION_WEB_SEARCH)) {
828                 // Create an encoded URL string.
829                 String encodedUrlString;
830
831                 // Sanitize the search input and convert it to a search.
832                 try {
833                     encodedUrlString = URLEncoder.encode(intent.getStringExtra(SearchManager.QUERY), "UTF-8");
834                 } catch (UnsupportedEncodingException exception) {
835                     encodedUrlString = "";
836                 }
837
838                 // Add the base search URL.
839                 url = searchURL + encodedUrlString;
840             } else {  // The intent should contain a URL.
841                 // Set the intent data as the URL.
842                 url = intentUriData.toString();
843             }
844
845             // Load the URL.
846             loadUrl(url);
847
848             // Get a handle for the drawer layout.
849             DrawerLayout drawerLayout = findViewById(R.id.drawerlayout);
850
851             // Close the navigation drawer if it is open.
852             if (drawerLayout.isDrawerVisible(GravityCompat.START)) {
853                 drawerLayout.closeDrawer(GravityCompat.START);
854             }
855
856             // Close the bookmarks drawer if it is open.
857             if (drawerLayout.isDrawerVisible(GravityCompat.END)) {
858                 drawerLayout.closeDrawer(GravityCompat.END);
859             }
860
861             // Clear the keyboard if displayed and remove the focus on the urlTextBar if it has it.
862             currentWebView.requestFocus();
863         }
864     }
865
866     @Override
867     public void onRestart() {
868         // Run the default commands.
869         super.onRestart();
870
871         // Make sure Orbot is running if Privacy Browser is proxying through Orbot.
872         if (proxyThroughOrbot) {
873             // Request Orbot to start.  If Orbot is already running no hard will be caused by this request.
874             Intent orbotIntent = new Intent("org.torproject.android.intent.action.START");
875
876             // Send the intent to the Orbot package.
877             orbotIntent.setPackage("org.torproject.android");
878
879             // Make it so.
880             sendBroadcast(orbotIntent);
881         }
882
883         // Apply the app settings if returning from the Settings activity.
884         if (reapplyAppSettingsOnRestart) {
885             // Reset the reapply app settings on restart tracker.
886             reapplyAppSettingsOnRestart = false;
887
888             // Apply the app settings.
889             applyAppSettings();
890         }
891
892         // Apply the domain settings if returning from the settings or domains activity.
893         if (reapplyDomainSettingsOnRestart) {
894             // Reset the reapply domain settings on restart tracker.
895             reapplyDomainSettingsOnRestart = false;
896
897             // Reapply the domain settings for each tab.
898             for (int i = 0; i < webViewPagerAdapter.getCount(); i++) {
899                 // Get the WebView tab fragment.
900                 WebViewTabFragment webViewTabFragment = webViewPagerAdapter.getPageFragment(i);
901
902                 // Get the fragment view.
903                 View fragmentView = webViewTabFragment.getView();
904
905                 // Only reload the WebViews if they exist.
906                 if (fragmentView != null) {
907                     // Get the nested scroll WebView from the tab fragment.
908                     NestedScrollWebView nestedScrollWebView = fragmentView.findViewById(R.id.nestedscroll_webview);
909
910                     // Reset the current domain name so the domain settings will be reapplied.
911                     nestedScrollWebView.resetCurrentDomainName();
912
913                     // Reapply the domain settings if the URL is not null, which can happen if an empty tab is active when returning from settings.
914                     if (nestedScrollWebView.getUrl() != null) {
915                         applyDomainSettings(nestedScrollWebView, nestedScrollWebView.getUrl(), false, true);
916                     }
917                 }
918             }
919         }
920
921         // Load the URL on restart (used when loading a bookmark).
922         if (loadUrlOnRestart) {
923             // Load the specified URL.
924             loadUrl(urlToLoadOnRestart);
925
926             // Reset the load on restart tracker.
927             loadUrlOnRestart = false;
928         }
929
930         // Update the bookmarks drawer if returning from the Bookmarks activity.
931         if (restartFromBookmarksActivity) {
932             // Get a handle for the drawer layout.
933             DrawerLayout drawerLayout = findViewById(R.id.drawerlayout);
934
935             // Close the bookmarks drawer.
936             drawerLayout.closeDrawer(GravityCompat.END);
937
938             // Reload the bookmarks drawer.
939             loadBookmarksFolder();
940
941             // Reset `restartFromBookmarksActivity`.
942             restartFromBookmarksActivity = false;
943         }
944
945         // Update the privacy icon.  `true` runs `invalidateOptionsMenu` as the last step.  This can be important if the screen was rotated.
946         updatePrivacyIcons(true);
947     }
948
949     // `onResume()` runs after `onStart()`, which runs after `onCreate()` and `onRestart()`.
950     @Override
951     public void onResume() {
952         // Run the default commands.
953         super.onResume();
954
955         for (int i = 0; i < webViewPagerAdapter.getCount(); i++) {
956             // Get the WebView tab fragment.
957             WebViewTabFragment webViewTabFragment = webViewPagerAdapter.getPageFragment(i);
958
959             // Get the fragment view.
960             View fragmentView = webViewTabFragment.getView();
961
962             // Only resume the WebViews if they exist (they won't when the app is first created).
963             if (fragmentView != null) {
964                 // Get the nested scroll WebView from the tab fragment.
965                 NestedScrollWebView nestedScrollWebView = fragmentView.findViewById(R.id.nestedscroll_webview);
966
967                 // Resume the nested scroll WebView JavaScript timers.
968                 nestedScrollWebView.resumeTimers();
969
970                 // Resume the nested scroll WebView.
971                 nestedScrollWebView.onResume();
972             }
973         }
974
975         // Display a message to the user if waiting for Orbot.
976         if (waitingForOrbot && !orbotStatus.equals("ON")) {
977             // Disable the wide view port so that the waiting for Orbot text is displayed correctly.
978             currentWebView.getSettings().setUseWideViewPort(false);
979
980             // Load a waiting page.  `null` specifies no encoding, which defaults to ASCII.
981             currentWebView.loadData("<html><body><br/><center><h1>" + getString(R.string.waiting_for_orbot) + "</h1></center></body></html>", "text/html", null);
982         }
983
984         if (displayingFullScreenVideo || inFullScreenBrowsingMode) {
985             // Get a handle for the root frame layouts.
986             FrameLayout rootFrameLayout = findViewById(R.id.root_framelayout);
987
988             // Remove the translucent status flag.  This is necessary so the root frame layout can fill the entire screen.
989             getWindow().clearFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS);
990
991             /* Hide the system bars.
992              * SYSTEM_UI_FLAG_FULLSCREEN hides the status bar at the top of the screen.
993              * SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN makes the root frame layout fill the area that is normally reserved for the status bar.
994              * SYSTEM_UI_FLAG_HIDE_NAVIGATION hides the navigation bar on the bottom or right of the screen.
995              * SYSTEM_UI_FLAG_IMMERSIVE_STICKY makes the status and navigation bars translucent and automatically re-hides them after they are shown.
996              */
997             rootFrameLayout.setSystemUiVisibility(View.SYSTEM_UI_FLAG_FULLSCREEN | View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN | View.SYSTEM_UI_FLAG_HIDE_NAVIGATION |
998                     View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY);
999         } else if (BuildConfig.FLAVOR.contentEquals("free")) {  // Resume the adView for the free flavor.
1000             // Resume the ad.
1001             AdHelper.resumeAd(findViewById(R.id.adview));
1002         }
1003     }
1004
1005     @Override
1006     public void onPause() {
1007         // Run the default commands.
1008         super.onPause();
1009
1010         for (int i = 0; i < webViewPagerAdapter.getCount(); i++) {
1011             // Get the WebView tab fragment.
1012             WebViewTabFragment webViewTabFragment = webViewPagerAdapter.getPageFragment(i);
1013
1014             // Get the fragment view.
1015             View fragmentView = webViewTabFragment.getView();
1016
1017             // Only pause the WebViews if they exist (they won't when the app is first created).
1018             if (fragmentView != null) {
1019                 // Get the nested scroll WebView from the tab fragment.
1020                 NestedScrollWebView nestedScrollWebView = fragmentView.findViewById(R.id.nestedscroll_webview);
1021
1022                 // Pause the nested scroll WebView.
1023                 nestedScrollWebView.onPause();
1024
1025                 // Pause the nested scroll WebView JavaScript timers.
1026                 nestedScrollWebView.pauseTimers();
1027             }
1028         }
1029
1030         // Pause the ad or it will continue to consume resources in the background on the free flavor.
1031         if (BuildConfig.FLAVOR.contentEquals("free")) {
1032             // Pause the ad.
1033             AdHelper.pauseAd(findViewById(R.id.adview));
1034         }
1035     }
1036
1037     @Override
1038     public void onDestroy() {
1039         // Unregister the Orbot status broadcast receiver.
1040         this.unregisterReceiver(orbotStatusBroadcastReceiver);
1041
1042         // Close the bookmarks cursor and database.
1043         bookmarksCursor.close();
1044         bookmarksDatabaseHelper.close();
1045
1046         // Run the default commands.
1047         super.onDestroy();
1048     }
1049
1050     @Override
1051     public boolean onCreateOptionsMenu(Menu menu) {
1052         // Inflate the menu.  This adds items to the action bar if it is present.
1053         getMenuInflater().inflate(R.menu.webview_options_menu, menu);
1054
1055         // Store a handle for the options menu so it can be used by `onOptionsItemSelected()` and `updatePrivacyIcons()`.
1056         optionsMenu = menu;
1057
1058         // Set the initial status of the privacy icons.  `false` does not call `invalidateOptionsMenu` as the last step.
1059         updatePrivacyIcons(false);
1060
1061         // Get handles for the menu items.
1062         MenuItem toggleFirstPartyCookiesMenuItem = menu.findItem(R.id.toggle_first_party_cookies);
1063         MenuItem toggleThirdPartyCookiesMenuItem = menu.findItem(R.id.toggle_third_party_cookies);
1064         MenuItem toggleDomStorageMenuItem = menu.findItem(R.id.toggle_dom_storage);
1065         MenuItem toggleSaveFormDataMenuItem = menu.findItem(R.id.toggle_save_form_data);  // Form data can be removed once the minimum API >= 26.
1066         MenuItem clearFormDataMenuItem = menu.findItem(R.id.clear_form_data);  // Form data can be removed once the minimum API >= 26.
1067         MenuItem refreshMenuItem = menu.findItem(R.id.refresh);
1068         MenuItem adConsentMenuItem = menu.findItem(R.id.ad_consent);
1069
1070         // Only display third-party cookies if API >= 21
1071         toggleThirdPartyCookiesMenuItem.setVisible(Build.VERSION.SDK_INT >= 21);
1072
1073         // Only display the form data menu items if the API < 26.
1074         toggleSaveFormDataMenuItem.setVisible(Build.VERSION.SDK_INT < 26);
1075         clearFormDataMenuItem.setVisible(Build.VERSION.SDK_INT < 26);
1076
1077         // Disable the clear form data menu item if the API >= 26 so that the status of the main Clear Data is calculated correctly.
1078         clearFormDataMenuItem.setEnabled(Build.VERSION.SDK_INT < 26);
1079
1080         // Only show Ad Consent if this is the free flavor.
1081         adConsentMenuItem.setVisible(BuildConfig.FLAVOR.contentEquals("free"));
1082
1083         // Get the shared preferences.
1084         SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(this);
1085
1086         // Get the dark theme and app bar preferences..
1087         boolean displayAdditionalAppBarIcons = sharedPreferences.getBoolean("display_additional_app_bar_icons", false);
1088         boolean darkTheme = sharedPreferences.getBoolean("dark_theme", false);
1089
1090         // 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.
1091         if (displayAdditionalAppBarIcons) {
1092             toggleFirstPartyCookiesMenuItem.setShowAsAction(MenuItem.SHOW_AS_ACTION_IF_ROOM);
1093             toggleDomStorageMenuItem.setShowAsAction(MenuItem.SHOW_AS_ACTION_IF_ROOM);
1094             refreshMenuItem.setShowAsAction(MenuItem.SHOW_AS_ACTION_ALWAYS);
1095         } else { //Do not display the additional icons.
1096             toggleFirstPartyCookiesMenuItem.setShowAsAction(MenuItem.SHOW_AS_ACTION_NEVER);
1097             toggleDomStorageMenuItem.setShowAsAction(MenuItem.SHOW_AS_ACTION_NEVER);
1098             refreshMenuItem.setShowAsAction(MenuItem.SHOW_AS_ACTION_NEVER);
1099         }
1100
1101         // Replace Refresh with Stop if a URL is already loading.
1102         if (currentWebView != null && currentWebView.getProgress() != 100) {
1103             // Set the title.
1104             refreshMenuItem.setTitle(R.string.stop);
1105
1106             // If the icon is displayed in the AppBar, set it according to the theme.
1107             if (displayAdditionalAppBarIcons) {
1108                 if (darkTheme) {
1109                     refreshMenuItem.setIcon(R.drawable.close_dark);
1110                 } else {
1111                     refreshMenuItem.setIcon(R.drawable.close_light);
1112                 }
1113             }
1114         }
1115
1116         return true;
1117     }
1118
1119     @Override
1120     public boolean onPrepareOptionsMenu(Menu menu) {
1121         // Get handles for the menu items.
1122         MenuItem addOrEditDomain = menu.findItem(R.id.add_or_edit_domain);
1123         MenuItem firstPartyCookiesMenuItem = menu.findItem(R.id.toggle_first_party_cookies);
1124         MenuItem thirdPartyCookiesMenuItem = menu.findItem(R.id.toggle_third_party_cookies);
1125         MenuItem domStorageMenuItem = menu.findItem(R.id.toggle_dom_storage);
1126         MenuItem saveFormDataMenuItem = menu.findItem(R.id.toggle_save_form_data);  // Form data can be removed once the minimum API >= 26.
1127         MenuItem clearDataMenuItem = menu.findItem(R.id.clear_data);
1128         MenuItem clearCookiesMenuItem = menu.findItem(R.id.clear_cookies);
1129         MenuItem clearDOMStorageMenuItem = menu.findItem(R.id.clear_dom_storage);
1130         MenuItem clearFormDataMenuItem = menu.findItem(R.id.clear_form_data);  // Form data can be removed once the minimum API >= 26.
1131         MenuItem blocklistsMenuItem = menu.findItem(R.id.blocklists);
1132         MenuItem easyListMenuItem = menu.findItem(R.id.easylist);
1133         MenuItem easyPrivacyMenuItem = menu.findItem(R.id.easyprivacy);
1134         MenuItem fanboysAnnoyanceListMenuItem = menu.findItem(R.id.fanboys_annoyance_list);
1135         MenuItem fanboysSocialBlockingListMenuItem = menu.findItem(R.id.fanboys_social_blocking_list);
1136         MenuItem ultraPrivacyMenuItem = menu.findItem(R.id.ultraprivacy);
1137         MenuItem blockAllThirdPartyRequestsMenuItem = menu.findItem(R.id.block_all_third_party_requests);
1138         MenuItem fontSizeMenuItem = menu.findItem(R.id.font_size);
1139         MenuItem swipeToRefreshMenuItem = menu.findItem(R.id.swipe_to_refresh);
1140         MenuItem displayImagesMenuItem = menu.findItem(R.id.display_images);
1141         MenuItem nightModeMenuItem = menu.findItem(R.id.night_mode);
1142         MenuItem proxyThroughOrbotMenuItem = menu.findItem(R.id.proxy_through_orbot);
1143
1144         // Get a handle for the cookie manager.
1145         CookieManager cookieManager = CookieManager.getInstance();
1146
1147         // Initialize the current user agent string and the font size.
1148         String currentUserAgent = getString(R.string.user_agent_privacy_browser);
1149         int fontSize = 100;
1150
1151         // 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.
1152         if (currentWebView != null) {
1153             // Set the add or edit domain text.
1154             if (currentWebView.getDomainSettingsApplied()) {
1155                 addOrEditDomain.setTitle(R.string.edit_domain_settings);
1156             } else {
1157                 addOrEditDomain.setTitle(R.string.add_domain_settings);
1158             }
1159
1160             // Get the current user agent from the WebView.
1161             currentUserAgent = currentWebView.getSettings().getUserAgentString();
1162
1163             // Get the current font size from the
1164             fontSize = currentWebView.getSettings().getTextZoom();
1165
1166             // Set the status of the menu item checkboxes.
1167             domStorageMenuItem.setChecked(currentWebView.getSettings().getDomStorageEnabled());
1168             saveFormDataMenuItem.setChecked(currentWebView.getSettings().getSaveFormData());  // Form data can be removed once the minimum API >= 26.
1169             easyListMenuItem.setChecked(currentWebView.isBlocklistEnabled(NestedScrollWebView.EASY_LIST));
1170             easyPrivacyMenuItem.setChecked(currentWebView.isBlocklistEnabled(NestedScrollWebView.EASY_PRIVACY));
1171             fanboysAnnoyanceListMenuItem.setChecked(currentWebView.isBlocklistEnabled(NestedScrollWebView.FANBOYS_ANNOYANCE_LIST));
1172             fanboysSocialBlockingListMenuItem.setChecked(currentWebView.isBlocklistEnabled(NestedScrollWebView.FANBOYS_SOCIAL_BLOCKING_LIST));
1173             ultraPrivacyMenuItem.setChecked(currentWebView.isBlocklistEnabled(NestedScrollWebView.ULTRA_PRIVACY));
1174             blockAllThirdPartyRequestsMenuItem.setChecked(currentWebView.isBlocklistEnabled(NestedScrollWebView.THIRD_PARTY_REQUESTS));
1175             swipeToRefreshMenuItem.setChecked(currentWebView.getSwipeToRefresh());
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                     if (Build.VERSION.SDK_INT >= 23) {  // For API >= 23, the status of the scroll refresh listener is continuously updated by the on scroll change listener.
1895                         // Only enable the swipe refresh layout if the WebView is scrolled to the top.
1896                         swipeRefreshLayout.setEnabled(currentWebView.getY() == 0);
1897                     } else {  // For API < 23, the swipe refresh layout is always enabled.
1898                         // Enable the swipe refresh layout.
1899                         swipeRefreshLayout.setEnabled(true);
1900                     }
1901                 } else {  // Swipe to refresh is disabled.
1902                     // Disable the swipe refresh layout.
1903                     swipeRefreshLayout.setEnabled(false);
1904                 }
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.view_source:
1976                 // Create an intent to launch the view source activity.
1977                 Intent viewSourceIntent = new Intent(this, ViewSourceActivity.class);
1978
1979                 // Add the variables to the intent.
1980                 viewSourceIntent.putExtra("user_agent", currentWebView.getSettings().getUserAgentString());
1981                 viewSourceIntent.putExtra("current_url", currentWebView.getUrl());
1982
1983                 // Make it so.
1984                 startActivity(viewSourceIntent);
1985                 return true;
1986
1987             case R.id.share_url:
1988                 // Setup the share string.
1989                 String shareString = currentWebView.getTitle() + " – " + currentWebView.getUrl();
1990
1991                 // Create the share intent.
1992                 Intent shareIntent = new Intent(Intent.ACTION_SEND);
1993                 shareIntent.putExtra(Intent.EXTRA_TEXT, shareString);
1994                 shareIntent.setType("text/plain");
1995
1996                 // Make it so.
1997                 startActivity(Intent.createChooser(shareIntent, getString(R.string.share_url)));
1998                 return true;
1999
2000             case R.id.print:
2001                 // Get a print manager instance.
2002                 PrintManager printManager = (PrintManager) getSystemService(Context.PRINT_SERVICE);
2003
2004                 // Remove the lint error below that print manager might be null.
2005                 assert printManager != null;
2006
2007                 // Create a print document adapter from the current WebView.
2008                 PrintDocumentAdapter printDocumentAdapter = currentWebView.createPrintDocumentAdapter();
2009
2010                 // Print the document.
2011                 printManager.print(getString(R.string.privacy_browser_web_page), printDocumentAdapter, null);
2012                 return true;
2013
2014             case R.id.open_with_app:
2015                 openWithApp(currentWebView.getUrl());
2016                 return true;
2017
2018             case R.id.open_with_browser:
2019                 openWithBrowser(currentWebView.getUrl());
2020                 return true;
2021
2022             case R.id.add_to_homescreen:
2023                 // Instantiate the create home screen shortcut dialog.
2024                 DialogFragment createHomeScreenShortcutDialogFragment = CreateHomeScreenShortcutDialog.createDialog(currentWebView.getTitle(), currentWebView.getUrl(),
2025                         currentWebView.getFavoriteOrDefaultIcon());
2026
2027                 // Show the create home screen shortcut dialog.
2028                 createHomeScreenShortcutDialogFragment.show(getSupportFragmentManager(), getString(R.string.create_shortcut));
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.close_tab:
2073                 // Get a handle for the tab layout and the view pager.
2074                 TabLayout tabLayout = findViewById(R.id.tablayout);
2075                 ViewPager webViewPager = findViewById(R.id.webviewpager);
2076
2077                 // Get the current tab number.
2078                 int currentTabNumber = tabLayout.getSelectedTabPosition();
2079
2080                 // Delete the current tab.
2081                 tabLayout.removeTabAt(currentTabNumber);
2082
2083                 // Delete the current page.  If the selected page number did not change during the delete, it will return true, meaning that the current WebView must be reset.
2084                 if (webViewPagerAdapter.deletePage(currentTabNumber, webViewPager)) {
2085                     setCurrentWebView(currentTabNumber);
2086                 }
2087                 break;
2088
2089             case R.id.clear_and_exit:
2090                 // Close the bookmarks cursor and database.
2091                 bookmarksCursor.close();
2092                 bookmarksDatabaseHelper.close();
2093
2094                 // Get the status of the clear everything preference.
2095                 boolean clearEverything = sharedPreferences.getBoolean("clear_everything", true);
2096
2097                 // Get a handle for the runtime.
2098                 Runtime runtime = Runtime.getRuntime();
2099
2100                 // Get the application's private data directory, which will be something like `/data/user/0/com.stoutner.privacybrowser.standard`,
2101                 // which links to `/data/data/com.stoutner.privacybrowser.standard`.
2102                 String privateDataDirectoryString = getApplicationInfo().dataDir;
2103
2104                 // Clear cookies.
2105                 if (clearEverything || sharedPreferences.getBoolean("clear_cookies", true)) {
2106                     // The command to remove cookies changed slightly in API 21.
2107                     if (Build.VERSION.SDK_INT >= 21) {
2108                         CookieManager.getInstance().removeAllCookies(null);
2109                     } else {
2110                         CookieManager.getInstance().removeAllCookie();
2111                     }
2112
2113                     // Manually delete the cookies database, as `CookieManager` sometimes will not flush its changes to disk before `System.exit(0)` is run.
2114                     try {
2115                         // Two commands must be used because `Runtime.exec()` does not like `*`.
2116                         Process deleteCookiesProcess = runtime.exec("rm -f " + privateDataDirectoryString + "/app_webview/Cookies");
2117                         Process deleteCookiesJournalProcess = runtime.exec("rm -f " + privateDataDirectoryString + "/app_webview/Cookies-journal");
2118
2119                         // Wait until the processes have finished.
2120                         deleteCookiesProcess.waitFor();
2121                         deleteCookiesJournalProcess.waitFor();
2122                     } catch (Exception exception) {
2123                         // Do nothing if an error is thrown.
2124                     }
2125                 }
2126
2127                 // Clear DOM storage.
2128                 if (clearEverything || sharedPreferences.getBoolean("clear_dom_storage", true)) {
2129                     // Ask `WebStorage` to clear the DOM storage.
2130                     WebStorage webStorage = WebStorage.getInstance();
2131                     webStorage.deleteAllData();
2132
2133                     // Manually delete the DOM storage files and directories, as `WebStorage` sometimes will not flush its changes to disk before `System.exit(0)` is run.
2134                     try {
2135                         // A `String[]` must be used because the directory contains a space and `Runtime.exec` will otherwise not escape the string correctly.
2136                         Process deleteLocalStorageProcess = runtime.exec(new String[] {"rm", "-rf", privateDataDirectoryString + "/app_webview/Local Storage/"});
2137
2138                         // Multiple commands must be used because `Runtime.exec()` does not like `*`.
2139                         Process deleteIndexProcess = runtime.exec("rm -rf " + privateDataDirectoryString + "/app_webview/IndexedDB");
2140                         Process deleteQuotaManagerProcess = runtime.exec("rm -f " + privateDataDirectoryString + "/app_webview/QuotaManager");
2141                         Process deleteQuotaManagerJournalProcess = runtime.exec("rm -f " + privateDataDirectoryString + "/app_webview/QuotaManager-journal");
2142                         Process deleteDatabaseProcess = runtime.exec("rm -rf " + privateDataDirectoryString + "/app_webview/databases");
2143
2144                         // Wait until the processes have finished.
2145                         deleteLocalStorageProcess.waitFor();
2146                         deleteIndexProcess.waitFor();
2147                         deleteQuotaManagerProcess.waitFor();
2148                         deleteQuotaManagerJournalProcess.waitFor();
2149                         deleteDatabaseProcess.waitFor();
2150                     } catch (Exception exception) {
2151                         // Do nothing if an error is thrown.
2152                     }
2153                 }
2154
2155                 // Clear form data if the API < 26.
2156                 if ((Build.VERSION.SDK_INT < 26) && (clearEverything || sharedPreferences.getBoolean("clear_form_data", true))) {
2157                     WebViewDatabase webViewDatabase = WebViewDatabase.getInstance(this);
2158                     webViewDatabase.clearFormData();
2159
2160                     // Manually delete the form data database, as `WebViewDatabase` sometimes will not flush its changes to disk before `System.exit(0)` is run.
2161                     try {
2162                         // A string array must be used because the database contains a space and `Runtime.exec` will not otherwise escape the string correctly.
2163                         Process deleteWebDataProcess = runtime.exec(new String[] {"rm", "-f", privateDataDirectoryString + "/app_webview/Web Data"});
2164                         Process deleteWebDataJournalProcess = runtime.exec(new String[] {"rm", "-f", privateDataDirectoryString + "/app_webview/Web Data-journal"});
2165
2166                         // Wait until the processes have finished.
2167                         deleteWebDataProcess.waitFor();
2168                         deleteWebDataJournalProcess.waitFor();
2169                     } catch (Exception exception) {
2170                         // Do nothing if an error is thrown.
2171                     }
2172                 }
2173
2174                 // Clear the cache.
2175                 if (clearEverything || sharedPreferences.getBoolean("clear_cache", true)) {
2176                     // Clear the cache from each WebView.
2177                     for (int i = 0; i < webViewPagerAdapter.getCount(); i++) {
2178                         // Get the WebView tab fragment.
2179                         WebViewTabFragment webViewTabFragment = webViewPagerAdapter.getPageFragment(i);
2180
2181                         // Get the fragment view.
2182                         View fragmentView = webViewTabFragment.getView();
2183
2184                         // Only clear the cache if the WebView exists.
2185                         if (fragmentView != null) {
2186                             // Get the nested scroll WebView from the tab fragment.
2187                             NestedScrollWebView nestedScrollWebView = fragmentView.findViewById(R.id.nestedscroll_webview);
2188
2189                             // Clear the cache for this WebView.
2190                             nestedScrollWebView.clearCache(true);
2191                         }
2192                     }
2193
2194                     // Manually delete the cache directories.
2195                     try {
2196                         // Delete the main cache directory.
2197                         Process deleteCacheProcess = runtime.exec("rm -rf " + privateDataDirectoryString + "/cache");
2198
2199                         // Delete the secondary `Service Worker` cache directory.
2200                         // A string array must be used because the directory contains a space and `Runtime.exec` will otherwise not escape the string correctly.
2201                         Process deleteServiceWorkerProcess = runtime.exec(new String[] {"rm", "-rf", privateDataDirectoryString + "/app_webview/Service Worker/"});
2202
2203                         // Wait until the processes have finished.
2204                         deleteCacheProcess.waitFor();
2205                         deleteServiceWorkerProcess.waitFor();
2206                     } catch (Exception exception) {
2207                         // Do nothing if an error is thrown.
2208                     }
2209                 }
2210
2211                 // Wipe out each WebView.
2212                 for (int i = 0; i < webViewPagerAdapter.getCount(); i++) {
2213                     // Get the WebView tab fragment.
2214                     WebViewTabFragment webViewTabFragment = webViewPagerAdapter.getPageFragment(i);
2215
2216                     // Get the fragment view.
2217                     View fragmentView = webViewTabFragment.getView();
2218
2219                     // Only wipe out the WebView if it exists.
2220                     if (fragmentView != null) {
2221                         // Get the nested scroll WebView from the tab fragment.
2222                         NestedScrollWebView nestedScrollWebView = fragmentView.findViewById(R.id.nestedscroll_webview);
2223
2224                         // Clear SSL certificate preferences for this WebView.
2225                         nestedScrollWebView.clearSslPreferences();
2226
2227                         // Clear the back/forward history for this WebView.
2228                         nestedScrollWebView.clearHistory();
2229
2230                         // Destroy the internal state of `mainWebView`.
2231                         nestedScrollWebView.destroy();
2232                     }
2233                 }
2234
2235                 // Clear the custom headers.
2236                 customHeaders.clear();
2237
2238                 // Manually delete the `app_webview` folder, which contains the cookies, DOM storage, form data, and `Service Worker` cache.
2239                 // See `https://code.google.com/p/android/issues/detail?id=233826&thanks=233826&ts=1486670530`.
2240                 if (clearEverything) {
2241                     try {
2242                         // Delete the folder.
2243                         Process deleteAppWebviewProcess = runtime.exec("rm -rf " + privateDataDirectoryString + "/app_webview");
2244
2245                         // Wait until the process has finished.
2246                         deleteAppWebviewProcess.waitFor();
2247                     } catch (Exception exception) {
2248                         // Do nothing if an error is thrown.
2249                     }
2250                 }
2251
2252                 // Close Privacy Browser.  `finishAndRemoveTask` also removes Privacy Browser from the recent app list.
2253                 if (Build.VERSION.SDK_INT >= 21) {
2254                     finishAndRemoveTask();
2255                 } else {
2256                     finish();
2257                 }
2258
2259                 // Remove the terminated program from RAM.  The status code is `0`.
2260                 System.exit(0);
2261                 break;
2262
2263             case R.id.home:
2264                 // Select the homepage based on the proxy through Orbot status.
2265                 if (proxyThroughOrbot) {
2266                     // Load the Tor homepage.
2267                     loadUrl(sharedPreferences.getString("tor_homepage", getString(R.string.tor_homepage_default_value)));
2268                 } else {
2269                     // Load the normal homepage.
2270                     loadUrl(sharedPreferences.getString("homepage", getString(R.string.homepage_default_value)));
2271                 }
2272                 break;
2273
2274             case R.id.back:
2275                 if (currentWebView.canGoBack()) {
2276                     // Reset the current domain name so that navigation works if third-party requests are blocked.
2277                     currentWebView.resetCurrentDomainName();
2278
2279                     // Set navigating history so that the domain settings are applied when the new URL is loaded.
2280                     currentWebView.setNavigatingHistory(true);
2281
2282                     // Load the previous website in the history.
2283                     currentWebView.goBack();
2284                 }
2285                 break;
2286
2287             case R.id.forward:
2288                 if (currentWebView.canGoForward()) {
2289                     // Reset the current domain name so that navigation works if third-party requests are blocked.
2290                     currentWebView.resetCurrentDomainName();
2291
2292                     // Set navigating history so that the domain settings are applied when the new URL is loaded.
2293                     currentWebView.setNavigatingHistory(true);
2294
2295                     // Load the next website in the history.
2296                     currentWebView.goForward();
2297                 }
2298                 break;
2299
2300             case R.id.history:
2301                 // Instantiate the URL history dialog.
2302                 DialogFragment urlHistoryDialogFragment = UrlHistoryDialog.loadBackForwardList(currentWebView.getWebViewFragmentId());
2303
2304                 // Show the URL history dialog.
2305                 urlHistoryDialogFragment.show(getSupportFragmentManager(), getString(R.string.history));
2306                 break;
2307
2308             case R.id.requests:
2309                 // Populate the resource requests.
2310                 RequestsActivity.resourceRequests = currentWebView.getResourceRequests();
2311
2312                 // Create an intent to launch the Requests activity.
2313                 Intent requestsIntent = new Intent(this, RequestsActivity.class);
2314
2315                 // Add the block third-party requests status to the intent.
2316                 requestsIntent.putExtra("block_all_third_party_requests", currentWebView.isBlocklistEnabled(NestedScrollWebView.THIRD_PARTY_REQUESTS));
2317
2318                 // Make it so.
2319                 startActivity(requestsIntent);
2320                 break;
2321
2322             case R.id.downloads:
2323                 // Launch the system Download Manager.
2324                 Intent downloadManagerIntent = new Intent(DownloadManager.ACTION_VIEW_DOWNLOADS);
2325
2326                 // Launch as a new task so that Download Manager and Privacy Browser show as separate windows in the recent tasks list.
2327                 downloadManagerIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
2328
2329                 startActivity(downloadManagerIntent);
2330                 break;
2331
2332             case R.id.domains:
2333                 // Set the flag to reapply the domain settings on restart when returning from Domain Settings.
2334                 reapplyDomainSettingsOnRestart = true;
2335
2336                 // Launch the domains activity.
2337                 Intent domainsIntent = new Intent(this, DomainsActivity.class);
2338
2339                 // Add the extra information to the intent.
2340                 domainsIntent.putExtra("current_url", currentWebView.getUrl());
2341
2342                 // Get the current certificate.
2343                 SslCertificate sslCertificate = currentWebView.getCertificate();
2344
2345                 // Check to see if the SSL certificate is populated.
2346                 if (sslCertificate != null) {
2347                     // Extract the certificate to strings.
2348                     String issuedToCName = sslCertificate.getIssuedTo().getCName();
2349                     String issuedToOName = sslCertificate.getIssuedTo().getOName();
2350                     String issuedToUName = sslCertificate.getIssuedTo().getUName();
2351                     String issuedByCName = sslCertificate.getIssuedBy().getCName();
2352                     String issuedByOName = sslCertificate.getIssuedBy().getOName();
2353                     String issuedByUName = sslCertificate.getIssuedBy().getUName();
2354                     long startDateLong = sslCertificate.getValidNotBeforeDate().getTime();
2355                     long endDateLong = sslCertificate.getValidNotAfterDate().getTime();
2356
2357                     // Add the certificate to the intent.
2358                     domainsIntent.putExtra("ssl_issued_to_cname", issuedToCName);
2359                     domainsIntent.putExtra("ssl_issued_to_oname", issuedToOName);
2360                     domainsIntent.putExtra("ssl_issued_to_uname", issuedToUName);
2361                     domainsIntent.putExtra("ssl_issued_by_cname", issuedByCName);
2362                     domainsIntent.putExtra("ssl_issued_by_oname", issuedByOName);
2363                     domainsIntent.putExtra("ssl_issued_by_uname", issuedByUName);
2364                     domainsIntent.putExtra("ssl_start_date", startDateLong);
2365                     domainsIntent.putExtra("ssl_end_date", endDateLong);
2366                 }
2367
2368                 // Check to see if the current IP addresses have been received.
2369                 if (currentWebView.hasCurrentIpAddresses()) {
2370                     // Add the current IP addresses to the intent.
2371                     domainsIntent.putExtra("current_ip_addresses", currentWebView.getCurrentIpAddresses());
2372                 }
2373
2374                 // Make it so.
2375                 startActivity(domainsIntent);
2376                 break;
2377
2378             case R.id.settings:
2379                 // Set the flag to reapply app settings on restart when returning from Settings.
2380                 reapplyAppSettingsOnRestart = true;
2381
2382                 // Set the flag to reapply the domain settings on restart when returning from Settings.
2383                 reapplyDomainSettingsOnRestart = true;
2384
2385                 // Launch the settings activity.
2386                 Intent settingsIntent = new Intent(this, SettingsActivity.class);
2387                 startActivity(settingsIntent);
2388                 break;
2389
2390             case R.id.import_export:
2391                 // Launch the import/export activity.
2392                 Intent importExportIntent = new Intent (this, ImportExportActivity.class);
2393                 startActivity(importExportIntent);
2394                 break;
2395
2396             case R.id.logcat:
2397                 // Launch the logcat activity.
2398                 Intent logcatIntent = new Intent(this, LogcatActivity.class);
2399                 startActivity(logcatIntent);
2400                 break;
2401
2402             case R.id.guide:
2403                 // Launch `GuideActivity`.
2404                 Intent guideIntent = new Intent(this, GuideActivity.class);
2405                 startActivity(guideIntent);
2406                 break;
2407
2408             case R.id.about:
2409                 // Create an intent to launch the about activity.
2410                 Intent aboutIntent = new Intent(this, AboutActivity.class);
2411
2412                 // Create a string array for the blocklist versions.
2413                 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],
2414                         ultraPrivacy.get(0).get(0)[0]};
2415
2416                 // Add the blocklist versions to the intent.
2417                 aboutIntent.putExtra("blocklist_versions", blocklistVersions);
2418
2419                 // Make it so.
2420                 startActivity(aboutIntent);
2421                 break;
2422         }
2423
2424         // Get a handle for the drawer layout.
2425         DrawerLayout drawerLayout = findViewById(R.id.drawerlayout);
2426
2427         // Close the navigation drawer.
2428         drawerLayout.closeDrawer(GravityCompat.START);
2429         return true;
2430     }
2431
2432     @Override
2433     public void onPostCreate(Bundle savedInstanceState) {
2434         // Run the default commands.
2435         super.onPostCreate(savedInstanceState);
2436
2437         // Sync the state of the DrawerToggle after the default `onRestoreInstanceState()` has finished.  This creates the navigation drawer icon.
2438         actionBarDrawerToggle.syncState();
2439     }
2440
2441     @Override
2442     public void onConfigurationChanged(Configuration newConfig) {
2443         // Run the default commands.
2444         super.onConfigurationChanged(newConfig);
2445
2446         // Get the status bar pixel size.
2447         int statusBarResourceId = getResources().getIdentifier("status_bar_height", "dimen", "android");
2448         int statusBarPixelSize = getResources().getDimensionPixelSize(statusBarResourceId);
2449
2450         // Get the resource density.
2451         float screenDensity = getResources().getDisplayMetrics().density;
2452
2453         // Recalculate the drawer header padding.
2454         drawerHeaderPaddingLeftAndRight = (int) (15 * screenDensity);
2455         drawerHeaderPaddingTop = statusBarPixelSize + (int) (4 * screenDensity);
2456         drawerHeaderPaddingBottom = (int) (8 * screenDensity);
2457
2458         // Reload the ad for the free flavor if not in full screen mode.
2459         if (BuildConfig.FLAVOR.contentEquals("free") && !inFullScreenBrowsingMode) {
2460             // Reload the ad.  The AdView is destroyed and recreated, which changes the ID, every time it is reloaded to handle possible rotations.
2461             AdHelper.loadAd(findViewById(R.id.adview), getApplicationContext(), getString(R.string.ad_unit_id));
2462         }
2463
2464         // `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:
2465         // https://code.google.com/p/android/issues/detail?id=20493#c8
2466         // ActivityCompat.invalidateOptionsMenu(this);
2467     }
2468
2469     @Override
2470     public void onCreateContextMenu(ContextMenu menu, View view, ContextMenu.ContextMenuInfo menuInfo) {
2471         // Store the hit test result.
2472         final WebView.HitTestResult hitTestResult = currentWebView.getHitTestResult();
2473
2474         // Create the URL strings.
2475         final String imageUrl;
2476         final String linkUrl;
2477
2478         // Get handles for the system managers.
2479         final ClipboardManager clipboardManager = (ClipboardManager) getSystemService(CLIPBOARD_SERVICE);
2480         FragmentManager fragmentManager = getSupportFragmentManager();
2481         SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(this);
2482
2483         // Remove the lint errors below that the clipboard manager might be null.
2484         assert clipboardManager != null;
2485
2486         // Process the link according to the type.
2487         switch (hitTestResult.getType()) {
2488             // `SRC_ANCHOR_TYPE` is a link.
2489             case WebView.HitTestResult.SRC_ANCHOR_TYPE:
2490                 // Get the target URL.
2491                 linkUrl = hitTestResult.getExtra();
2492
2493                 // Set the target URL as the title of the `ContextMenu`.
2494                 menu.setHeaderTitle(linkUrl);
2495
2496                 // Add a Load URL entry.
2497                 menu.add(R.string.open_in_new_tab).setOnMenuItemClickListener((MenuItem item) -> {
2498                     // Add a new tab.
2499                     addTab(null);
2500
2501                     // Load the URL.
2502                     loadUrl(linkUrl);
2503                     return false;
2504                 });
2505
2506                 // Add an Open with App entry.
2507                 menu.add(R.string.open_with_app).setOnMenuItemClickListener((MenuItem item) -> {
2508                     openWithApp(linkUrl);
2509                     return false;
2510                 });
2511
2512                 // Add an Open with Browser entry.
2513                 menu.add(R.string.open_with_browser).setOnMenuItemClickListener((MenuItem item) -> {
2514                     openWithBrowser(linkUrl);
2515                     return false;
2516                 });
2517
2518                 // Add a Copy URL entry.
2519                 menu.add(R.string.copy_url).setOnMenuItemClickListener((MenuItem item) -> {
2520                     // Save the link URL in a `ClipData`.
2521                     ClipData srcAnchorTypeClipData = ClipData.newPlainText(getString(R.string.url), linkUrl);
2522
2523                     // Set the `ClipData` as the clipboard's primary clip.
2524                     clipboardManager.setPrimaryClip(srcAnchorTypeClipData);
2525                     return false;
2526                 });
2527
2528                 // Add a Download URL entry.
2529                 menu.add(R.string.download_url).setOnMenuItemClickListener((MenuItem item) -> {
2530                     // Check if the download should be processed by an external app.
2531                     if (sharedPreferences.getBoolean("download_with_external_app", false)) {  // Download with an external app.
2532                         openUrlWithExternalApp(linkUrl);
2533                     } else {  // Download with Android's download manager.
2534                         // Check to see if the storage permission has already been granted.
2535                         if (ContextCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE) == PackageManager.PERMISSION_DENIED) {  // The storage permission needs to be requested.
2536                             // Store the variables for future use by `onRequestPermissionsResult()`.
2537                             downloadUrl = linkUrl;
2538                             downloadContentDisposition = "none";
2539                             downloadContentLength = -1;
2540
2541                             // Show a dialog if the user has previously denied the permission.
2542                             if (ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.WRITE_EXTERNAL_STORAGE)) {  // Show a dialog explaining the request first.
2543                                 // Instantiate the download location permission alert dialog and set the download type to DOWNLOAD_FILE.
2544                                 DialogFragment downloadLocationPermissionDialogFragment = DownloadLocationPermissionDialog.downloadType(DownloadLocationPermissionDialog.DOWNLOAD_FILE);
2545
2546                                 // Show the download location permission alert dialog.  The permission will be requested when the the dialog is closed.
2547                                 downloadLocationPermissionDialogFragment.show(fragmentManager, getString(R.string.download_location));
2548                             } else {  // Show the permission request directly.
2549                                 // Request the permission.  The download dialog will be launched by `onRequestPermissionResult()`.
2550                                 ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE}, DOWNLOAD_FILE_REQUEST_CODE);
2551                             }
2552                         } else {  // The storage permission has already been granted.
2553                             // Get a handle for the download file alert dialog.
2554                             DialogFragment downloadFileDialogFragment = DownloadFileDialog.fromUrl(linkUrl, "none", -1);
2555
2556                             // Show the download file alert dialog.
2557                             downloadFileDialogFragment.show(fragmentManager, getString(R.string.download));
2558                         }
2559                     }
2560                     return false;
2561                 });
2562
2563                 // Add a Cancel entry, which by default closes the context menu.
2564                 menu.add(R.string.cancel);
2565                 break;
2566
2567             case WebView.HitTestResult.EMAIL_TYPE:
2568                 // Get the target URL.
2569                 linkUrl = hitTestResult.getExtra();
2570
2571                 // Set the target URL as the title of the `ContextMenu`.
2572                 menu.setHeaderTitle(linkUrl);
2573
2574                 // Add a Write Email entry.
2575                 menu.add(R.string.write_email).setOnMenuItemClickListener(item -> {
2576                     // Use `ACTION_SENDTO` instead of `ACTION_SEND` so that only email programs are launched.
2577                     Intent emailIntent = new Intent(Intent.ACTION_SENDTO);
2578
2579                     // Parse the url and set it as the data for the `Intent`.
2580                     emailIntent.setData(Uri.parse("mailto:" + linkUrl));
2581
2582                     // `FLAG_ACTIVITY_NEW_TASK` opens the email program in a new task instead as part of Privacy Browser.
2583                     emailIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
2584
2585                     // Make it so.
2586                     startActivity(emailIntent);
2587                     return false;
2588                 });
2589
2590                 // Add a Copy Email Address entry.
2591                 menu.add(R.string.copy_email_address).setOnMenuItemClickListener(item -> {
2592                     // Save the email address in a `ClipData`.
2593                     ClipData srcEmailTypeClipData = ClipData.newPlainText(getString(R.string.email_address), linkUrl);
2594
2595                     // Set the `ClipData` as the clipboard's primary clip.
2596                     clipboardManager.setPrimaryClip(srcEmailTypeClipData);
2597                     return false;
2598                 });
2599
2600                 // Add a `Cancel` entry, which by default closes the `ContextMenu`.
2601                 menu.add(R.string.cancel);
2602                 break;
2603
2604             // `IMAGE_TYPE` is an image.
2605             case WebView.HitTestResult.IMAGE_TYPE:
2606                 // Get the image URL.
2607                 imageUrl = hitTestResult.getExtra();
2608
2609                 // Set the image URL as the title of the `ContextMenu`.
2610                 menu.setHeaderTitle(imageUrl);
2611
2612                 // Add a View Image entry.
2613                 menu.add(R.string.view_image).setOnMenuItemClickListener(item -> {
2614                     loadUrl(imageUrl);
2615                     return false;
2616                 });
2617
2618                 // Add a Download Image entry.
2619                 menu.add(R.string.download_image).setOnMenuItemClickListener((MenuItem item) -> {
2620                     // Check if the download should be processed by an external app.
2621                     if (sharedPreferences.getBoolean("download_with_external_app", false)) {  // Download with an external app.
2622                         openUrlWithExternalApp(imageUrl);
2623                     } else {  // Download with Android's download manager.
2624                         // Check to see if the storage permission has already been granted.
2625                         if (ContextCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE) == PackageManager.PERMISSION_DENIED) {  // The storage permission needs to be requested.
2626                             // Store the image URL for use by `onRequestPermissionResult()`.
2627                             downloadImageUrl = imageUrl;
2628
2629                             // Show a dialog if the user has previously denied the permission.
2630                             if (ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.WRITE_EXTERNAL_STORAGE)) {  // Show a dialog explaining the request first.
2631                                 // Instantiate the download location permission alert dialog and set the download type to DOWNLOAD_IMAGE.
2632                                 DialogFragment downloadLocationPermissionDialogFragment = DownloadLocationPermissionDialog.downloadType(DownloadLocationPermissionDialog.DOWNLOAD_IMAGE);
2633
2634                                 // Show the download location permission alert dialog.  The permission will be requested when the dialog is closed.
2635                                 downloadLocationPermissionDialogFragment.show(fragmentManager, getString(R.string.download_location));
2636                             } else {  // Show the permission request directly.
2637                                 // Request the permission.  The download dialog will be launched by `onRequestPermissionResult().
2638                                 ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE}, DOWNLOAD_IMAGE_REQUEST_CODE);
2639                             }
2640                         } else {  // The storage permission has already been granted.
2641                             // Get a handle for the download image alert dialog.
2642                             DialogFragment downloadImageDialogFragment = DownloadImageDialog.imageUrl(imageUrl);
2643
2644                             // Show the download image alert dialog.
2645                             downloadImageDialogFragment.show(fragmentManager, getString(R.string.download));
2646                         }
2647                     }
2648                     return false;
2649                 });
2650
2651                 // Add a Copy URL entry.
2652                 menu.add(R.string.copy_url).setOnMenuItemClickListener(item -> {
2653                     // Save the image URL in a `ClipData`.
2654                     ClipData srcImageTypeClipData = ClipData.newPlainText(getString(R.string.url), imageUrl);
2655
2656                     // Set the `ClipData` as the clipboard's primary clip.
2657                     clipboardManager.setPrimaryClip(srcImageTypeClipData);
2658                     return false;
2659                 });
2660
2661                 // Add an Open with App entry.
2662                 menu.add(R.string.open_with_app).setOnMenuItemClickListener((MenuItem item) -> {
2663                     openWithApp(imageUrl);
2664                     return false;
2665                 });
2666
2667                 // Add an Open with Browser entry.
2668                 menu.add(R.string.open_with_browser).setOnMenuItemClickListener((MenuItem item) -> {
2669                     openWithBrowser(imageUrl);
2670                     return false;
2671                 });
2672
2673                 // Add a `Cancel` entry, which by default closes the `ContextMenu`.
2674                 menu.add(R.string.cancel);
2675                 break;
2676
2677
2678             // `SRC_IMAGE_ANCHOR_TYPE` is an image that is also a link.
2679             case WebView.HitTestResult.SRC_IMAGE_ANCHOR_TYPE:
2680                 // Get the image URL.
2681                 imageUrl = hitTestResult.getExtra();
2682
2683                 // Set the image URL as the title of the `ContextMenu`.
2684                 menu.setHeaderTitle(imageUrl);
2685
2686                 // Add a `View Image` entry.
2687                 menu.add(R.string.view_image).setOnMenuItemClickListener(item -> {
2688                     loadUrl(imageUrl);
2689                     return false;
2690                 });
2691
2692                 // Add a `Download Image` entry.
2693                 menu.add(R.string.download_image).setOnMenuItemClickListener((MenuItem item) -> {
2694                     // Check if the download should be processed by an external app.
2695                     if (sharedPreferences.getBoolean("download_with_external_app", false)) {  // Download with an external app.
2696                         openUrlWithExternalApp(imageUrl);
2697                     } else {  // Download with Android's download manager.
2698                         // Check to see if the storage permission has already been granted.
2699                         if (ContextCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE) == PackageManager.PERMISSION_DENIED) {  // The storage permission needs to be requested.
2700                             // Store the image URL for use by `onRequestPermissionResult()`.
2701                             downloadImageUrl = imageUrl;
2702
2703                             // Show a dialog if the user has previously denied the permission.
2704                             if (ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.WRITE_EXTERNAL_STORAGE)) {  // Show a dialog explaining the request first.
2705                                 // Instantiate the download location permission alert dialog and set the download type to DOWNLOAD_IMAGE.
2706                                 DialogFragment downloadLocationPermissionDialogFragment = DownloadLocationPermissionDialog.downloadType(DownloadLocationPermissionDialog.DOWNLOAD_IMAGE);
2707
2708                                 // Show the download location permission alert dialog.  The permission will be requested when the dialog is closed.
2709                                 downloadLocationPermissionDialogFragment.show(fragmentManager, getString(R.string.download_location));
2710                             } else {  // Show the permission request directly.
2711                                 // Request the permission.  The download dialog will be launched by `onRequestPermissionResult().
2712                                 ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE}, DOWNLOAD_IMAGE_REQUEST_CODE);
2713                             }
2714                         } else {  // The storage permission has already been granted.
2715                             // Get a handle for the download image alert dialog.
2716                             DialogFragment downloadImageDialogFragment = DownloadImageDialog.imageUrl(imageUrl);
2717
2718                             // Show the download image alert dialog.
2719                             downloadImageDialogFragment.show(fragmentManager, getString(R.string.download));
2720                         }
2721                     }
2722                     return false;
2723                 });
2724
2725                 // Add a `Copy URL` entry.
2726                 menu.add(R.string.copy_url).setOnMenuItemClickListener(item -> {
2727                     // Save the image URL in a `ClipData`.
2728                     ClipData srcImageAnchorTypeClipData = ClipData.newPlainText(getString(R.string.url), imageUrl);
2729
2730                     // Set the `ClipData` as the clipboard's primary clip.
2731                     clipboardManager.setPrimaryClip(srcImageAnchorTypeClipData);
2732                     return false;
2733                 });
2734
2735                 // Add an Open with App entry.
2736                 menu.add(R.string.open_with_app).setOnMenuItemClickListener((MenuItem item) -> {
2737                     openWithApp(imageUrl);
2738                     return false;
2739                 });
2740
2741                 // Add an Open with Browser entry.
2742                 menu.add(R.string.open_with_browser).setOnMenuItemClickListener((MenuItem item) -> {
2743                     openWithBrowser(imageUrl);
2744                     return false;
2745                 });
2746
2747                 // Add a `Cancel` entry, which by default closes the `ContextMenu`.
2748                 menu.add(R.string.cancel);
2749                 break;
2750         }
2751     }
2752
2753     @Override
2754     public void onCreateBookmark(DialogFragment dialogFragment, Bitmap favoriteIconBitmap) {
2755         // Get a handle for the bookmarks list view.
2756         ListView bookmarksListView = findViewById(R.id.bookmarks_drawer_listview);
2757
2758         // Get the views from the dialog fragment.
2759         EditText createBookmarkNameEditText = dialogFragment.getDialog().findViewById(R.id.create_bookmark_name_edittext);
2760         EditText createBookmarkUrlEditText = dialogFragment.getDialog().findViewById(R.id.create_bookmark_url_edittext);
2761
2762         // Extract the strings from the edit texts.
2763         String bookmarkNameString = createBookmarkNameEditText.getText().toString();
2764         String bookmarkUrlString = createBookmarkUrlEditText.getText().toString();
2765
2766         // Create a favorite icon byte array output stream.
2767         ByteArrayOutputStream favoriteIconByteArrayOutputStream = new ByteArrayOutputStream();
2768
2769         // Convert the favorite icon bitmap to a byte array.  `0` is for lossless compression (the only option for a PNG).
2770         favoriteIconBitmap.compress(Bitmap.CompressFormat.PNG, 0, favoriteIconByteArrayOutputStream);
2771
2772         // Convert the favorite icon byte array stream to a byte array.
2773         byte[] favoriteIconByteArray = favoriteIconByteArrayOutputStream.toByteArray();
2774
2775         // Display the new bookmark below the current items in the (0 indexed) list.
2776         int newBookmarkDisplayOrder = bookmarksListView.getCount();
2777
2778         // Create the bookmark.
2779         bookmarksDatabaseHelper.createBookmark(bookmarkNameString, bookmarkUrlString, currentBookmarksFolder, newBookmarkDisplayOrder, favoriteIconByteArray);
2780
2781         // Update the bookmarks cursor with the current contents of this folder.
2782         bookmarksCursor = bookmarksDatabaseHelper.getBookmarksByDisplayOrder(currentBookmarksFolder);
2783
2784         // Update the list view.
2785         bookmarksCursorAdapter.changeCursor(bookmarksCursor);
2786
2787         // Scroll to the new bookmark.
2788         bookmarksListView.setSelection(newBookmarkDisplayOrder);
2789     }
2790
2791     @Override
2792     public void onCreateBookmarkFolder(DialogFragment dialogFragment, Bitmap favoriteIconBitmap) {
2793         // Get a handle for the bookmarks list view.
2794         ListView bookmarksListView = findViewById(R.id.bookmarks_drawer_listview);
2795
2796         // Get handles for the views in the dialog fragment.
2797         EditText createFolderNameEditText = dialogFragment.getDialog().findViewById(R.id.create_folder_name_edittext);
2798         RadioButton defaultFolderIconRadioButton = dialogFragment.getDialog().findViewById(R.id.create_folder_default_icon_radiobutton);
2799         ImageView folderIconImageView = dialogFragment.getDialog().findViewById(R.id.create_folder_default_icon);
2800
2801         // Get new folder name string.
2802         String folderNameString = createFolderNameEditText.getText().toString();
2803
2804         // Create a folder icon bitmap.
2805         Bitmap folderIconBitmap;
2806
2807         // Set the folder icon bitmap according to the dialog.
2808         if (defaultFolderIconRadioButton.isChecked()) {  // Use the default folder icon.
2809             // Get the default folder icon drawable.
2810             Drawable folderIconDrawable = folderIconImageView.getDrawable();
2811
2812             // Convert the folder icon drawable to a bitmap drawable.
2813             BitmapDrawable folderIconBitmapDrawable = (BitmapDrawable) folderIconDrawable;
2814
2815             // Convert the folder icon bitmap drawable to a bitmap.
2816             folderIconBitmap = folderIconBitmapDrawable.getBitmap();
2817         } else {  // Use the WebView favorite icon.
2818             // Copy the favorite icon bitmap to the folder icon bitmap.
2819             folderIconBitmap = favoriteIconBitmap;
2820         }
2821
2822         // Create a folder icon byte array output stream.
2823         ByteArrayOutputStream folderIconByteArrayOutputStream = new ByteArrayOutputStream();
2824
2825         // Convert the folder icon bitmap to a byte array.  `0` is for lossless compression (the only option for a PNG).
2826         folderIconBitmap.compress(Bitmap.CompressFormat.PNG, 0, folderIconByteArrayOutputStream);
2827
2828         // Convert the folder icon byte array stream to a byte array.
2829         byte[] folderIconByteArray = folderIconByteArrayOutputStream.toByteArray();
2830
2831         // Move all the bookmarks down one in the display order.
2832         for (int i = 0; i < bookmarksListView.getCount(); i++) {
2833             int databaseId = (int) bookmarksListView.getItemIdAtPosition(i);
2834             bookmarksDatabaseHelper.updateDisplayOrder(databaseId, i + 1);
2835         }
2836
2837         // Create the folder, which will be placed at the top of the `ListView`.
2838         bookmarksDatabaseHelper.createFolder(folderNameString, currentBookmarksFolder, folderIconByteArray);
2839
2840         // Update the bookmarks cursor with the current contents of this folder.
2841         bookmarksCursor = bookmarksDatabaseHelper.getBookmarksByDisplayOrder(currentBookmarksFolder);
2842
2843         // Update the `ListView`.
2844         bookmarksCursorAdapter.changeCursor(bookmarksCursor);
2845
2846         // Scroll to the new folder.
2847         bookmarksListView.setSelection(0);
2848     }
2849
2850     @Override
2851     public void onSaveBookmark(DialogFragment dialogFragment, int selectedBookmarkDatabaseId, Bitmap favoriteIconBitmap) {
2852         // Get handles for the views from `dialogFragment`.
2853         EditText editBookmarkNameEditText = dialogFragment.getDialog().findViewById(R.id.edit_bookmark_name_edittext);
2854         EditText editBookmarkUrlEditText = dialogFragment.getDialog().findViewById(R.id.edit_bookmark_url_edittext);
2855         RadioButton currentBookmarkIconRadioButton = dialogFragment.getDialog().findViewById(R.id.edit_bookmark_current_icon_radiobutton);
2856
2857         // Store the bookmark strings.
2858         String bookmarkNameString = editBookmarkNameEditText.getText().toString();
2859         String bookmarkUrlString = editBookmarkUrlEditText.getText().toString();
2860
2861         // Update the bookmark.
2862         if (currentBookmarkIconRadioButton.isChecked()) {  // Update the bookmark without changing the favorite icon.
2863             bookmarksDatabaseHelper.updateBookmark(selectedBookmarkDatabaseId, bookmarkNameString, bookmarkUrlString);
2864         } else {  // Update the bookmark using the `WebView` favorite icon.
2865             // Create a favorite icon byte array output stream.
2866             ByteArrayOutputStream newFavoriteIconByteArrayOutputStream = new ByteArrayOutputStream();
2867
2868             // Convert the favorite icon bitmap to a byte array.  `0` is for lossless compression (the only option for a PNG).
2869             favoriteIconBitmap.compress(Bitmap.CompressFormat.PNG, 0, newFavoriteIconByteArrayOutputStream);
2870
2871             // Convert the favorite icon byte array stream to a byte array.
2872             byte[] newFavoriteIconByteArray = newFavoriteIconByteArrayOutputStream.toByteArray();
2873
2874             //  Update the bookmark and the favorite icon.
2875             bookmarksDatabaseHelper.updateBookmark(selectedBookmarkDatabaseId, bookmarkNameString, bookmarkUrlString, newFavoriteIconByteArray);
2876         }
2877
2878         // Update the bookmarks cursor with the current contents of this folder.
2879         bookmarksCursor = bookmarksDatabaseHelper.getBookmarksByDisplayOrder(currentBookmarksFolder);
2880
2881         // Update the list view.
2882         bookmarksCursorAdapter.changeCursor(bookmarksCursor);
2883     }
2884
2885     @Override
2886     public void onSaveBookmarkFolder(DialogFragment dialogFragment, int selectedFolderDatabaseId, Bitmap favoriteIconBitmap) {
2887         // Get handles for the views from `dialogFragment`.
2888         EditText editFolderNameEditText = dialogFragment.getDialog().findViewById(R.id.edit_folder_name_edittext);
2889         RadioButton currentFolderIconRadioButton = dialogFragment.getDialog().findViewById(R.id.edit_folder_current_icon_radiobutton);
2890         RadioButton defaultFolderIconRadioButton = dialogFragment.getDialog().findViewById(R.id.edit_folder_default_icon_radiobutton);
2891         ImageView defaultFolderIconImageView = dialogFragment.getDialog().findViewById(R.id.edit_folder_default_icon_imageview);
2892
2893         // Get the new folder name.
2894         String newFolderNameString = editFolderNameEditText.getText().toString();
2895
2896         // Check if the favorite icon has changed.
2897         if (currentFolderIconRadioButton.isChecked()) {  // Only the name has changed.
2898             // Update the name in the database.
2899             bookmarksDatabaseHelper.updateFolder(selectedFolderDatabaseId, oldFolderNameString, newFolderNameString);
2900         } else if (!currentFolderIconRadioButton.isChecked() && newFolderNameString.equals(oldFolderNameString)) {  // Only the icon has changed.
2901             // Create the new folder icon Bitmap.
2902             Bitmap folderIconBitmap;
2903
2904             // Populate the new folder icon bitmap.
2905             if (defaultFolderIconRadioButton.isChecked()) {
2906                 // Get the default folder icon drawable.
2907                 Drawable folderIconDrawable = defaultFolderIconImageView.getDrawable();
2908
2909                 // Convert the folder icon drawable to a bitmap drawable.
2910                 BitmapDrawable folderIconBitmapDrawable = (BitmapDrawable) folderIconDrawable;
2911
2912                 // Convert the folder icon bitmap drawable to a bitmap.
2913