Teach resource requests to be tab aware.
authorSoren Stoutner <soren@stoutner.com>
Thu, 28 Mar 2019 21:08:40 +0000 (14:08 -0700)
committerSoren Stoutner <soren@stoutner.com>
Thu, 28 Mar 2019 21:08:40 +0000 (14:08 -0700)
app/src/main/java/com/stoutner/privacybrowser/activities/MainWebViewActivity.java
app/src/main/java/com/stoutner/privacybrowser/activities/RequestsActivity.java
app/src/main/java/com/stoutner/privacybrowser/adapters/RequestsArrayAdapter.java
app/src/main/java/com/stoutner/privacybrowser/dialogs/ViewRequestDialog.java
app/src/main/java/com/stoutner/privacybrowser/helpers/BlockListHelper.java
app/src/main/java/com/stoutner/privacybrowser/views/NestedScrollWebView.java

index caecde4c46dca4427dda9e01a137eded16325e21..e6ec1b71cebebd8dc39c490b79c1ba37d50cb656 100644 (file)
@@ -160,25 +160,20 @@ public class MainWebViewActivity extends AppCompatActivity implements CreateBook
         EditBookmarkFolderDialog.EditBookmarkFolderListener, HttpAuthenticationDialog.HttpAuthenticationListener, NavigationView.OnNavigationItemSelectedListener, WebViewTabFragment.NewTabListener,
         PinnedMismatchDialog.PinnedMismatchListener, SslCertificateErrorDialog.SslCertificateErrorListener, UrlHistoryDialog.UrlHistoryListener {
 
         EditBookmarkFolderDialog.EditBookmarkFolderListener, HttpAuthenticationDialog.HttpAuthenticationListener, NavigationView.OnNavigationItemSelectedListener, WebViewTabFragment.NewTabListener,
         PinnedMismatchDialog.PinnedMismatchListener, SslCertificateErrorDialog.SslCertificateErrorListener, UrlHistoryDialog.UrlHistoryListener {
 
-    // TODO Consider removing
     // `darkTheme` is public static so it can be accessed from everywhere.
     public static boolean darkTheme;
 
     // `darkTheme` is public static so it can be accessed from everywhere.
     public static boolean darkTheme;
 
-    // TODO Consider removing
     // `allowScreenshots` is public static so it can be accessed from everywhere.  It is also used in `onCreate()`.
     public static boolean allowScreenshots;
 
     // `allowScreenshots` is public static so it can be accessed from everywhere.  It is also used in `onCreate()`.
     public static boolean allowScreenshots;
 
-    // TODO Remove
     // `favoriteIconBitmap` is public static so it can be accessed from `BookmarksActivity`, `BookmarksDatabaseViewActivity`, `CreateBookmarkFolderDialog`,
     // `EditBookmarkDialog`, `EditBookmarkFolderDialog`, `EditBookmarkDatabaseViewDialog`, and `ViewSslCertificateDialog`.  It is also used in `onCreate()`, `onCreateBookmark()`, `onCreateBookmarkFolder()`,
     // `onCreateHomeScreenShortcut()`, `onSaveEditBookmark()`, `onSaveEditBookmarkFolder()`, and `applyDomainSettings()`.
     public static Bitmap favoriteIconBitmap;
 
     // `favoriteIconBitmap` is public static so it can be accessed from `BookmarksActivity`, `BookmarksDatabaseViewActivity`, `CreateBookmarkFolderDialog`,
     // `EditBookmarkDialog`, `EditBookmarkFolderDialog`, `EditBookmarkDatabaseViewDialog`, and `ViewSslCertificateDialog`.  It is also used in `onCreate()`, `onCreateBookmark()`, `onCreateBookmarkFolder()`,
     // `onCreateHomeScreenShortcut()`, `onSaveEditBookmark()`, `onSaveEditBookmarkFolder()`, and `applyDomainSettings()`.
     public static Bitmap favoriteIconBitmap;
 
-    // TODO Remove
     // `favoriteIconDefaultBitmap` public static so it can be accessed from `PinnedMismatchDialog`.  It is also used in `onCreate()` and `applyDomainSettings`.
     public static Bitmap favoriteIconDefaultBitmap;
 
     // `favoriteIconDefaultBitmap` public static so it can be accessed from `PinnedMismatchDialog`.  It is also used in `onCreate()` and `applyDomainSettings`.
     public static Bitmap favoriteIconDefaultBitmap;
 
-    // TODO Consider removing the formatted URL string.
     // `formattedUrlString` is public static so it can be accessed from `AddDomainDialog`, `BookmarksActivity`, `DomainSettingsFragment`, and `PinnedMismatchDialog`.
     // It is also used in `onCreate()`, `onOptionsItemSelected()`, `onNavigationItemSelected()`, `onCreateHomeScreenShortcutCreate()`, `loadUrlFromTextBox()`, and `applyProxyThroughOrbot()`.
     public static String formattedUrlString;
     // `formattedUrlString` is public static so it can be accessed from `AddDomainDialog`, `BookmarksActivity`, `DomainSettingsFragment`, and `PinnedMismatchDialog`.
     // It is also used in `onCreate()`, `onOptionsItemSelected()`, `onNavigationItemSelected()`, `onCreateHomeScreenShortcutCreate()`, `loadUrlFromTextBox()`, and `applyProxyThroughOrbot()`.
     public static String formattedUrlString;
@@ -213,60 +208,13 @@ public class MainWebViewActivity extends AppCompatActivity implements CreateBook
     // `restartFromBookmarksActivity` is public static so it can be accessed from `BookmarksActivity`.  It is also used in `onRestart()`.
     public static boolean restartFromBookmarksActivity;
 
     // `restartFromBookmarksActivity` is public static so it can be accessed from `BookmarksActivity`.  It is also used in `onRestart()`.
     public static boolean restartFromBookmarksActivity;
 
-    // The block list versions are public static so they can be accessed from `AboutTabFragment`.  They are also used in `onCreate()`.
+    // The blocklist versions are public static so they can be accessed from `AboutTabFragment`.  They are also used in `onCreate()`.
     public static String easyListVersion;
     public static String easyPrivacyVersion;
     public static String fanboysAnnoyanceVersion;
     public static String fanboysSocialVersion;
     public static String ultraPrivacyVersion;
 
     public static String easyListVersion;
     public static String easyPrivacyVersion;
     public static String fanboysAnnoyanceVersion;
     public static String fanboysSocialVersion;
     public static String ultraPrivacyVersion;
 
-    // The request items are public static so they can be accessed by `BlockListHelper`, `RequestsArrayAdapter`, and `ViewRequestsDialog`.  They are also used in `onCreate()` and `onPrepareOptionsMenu()`.
-    public static List<String[]> resourceRequests;
-    public static String[] whiteListResultStringArray;
-    private int blockedRequests;
-    private int easyListBlockedRequests;
-    private int easyPrivacyBlockedRequests;
-    private int fanboysAnnoyanceListBlockedRequests;
-    private int fanboysSocialBlockingListBlockedRequests;
-    private int ultraPrivacyBlockedRequests;
-    private int thirdPartyBlockedRequests;
-
-    public final static int REQUEST_DISPOSITION = 0;
-    public final static int REQUEST_URL = 1;
-    public final static int REQUEST_BLOCKLIST = 2;
-    public final static int REQUEST_SUBLIST = 3;
-    public final static int REQUEST_BLOCKLIST_ENTRIES = 4;
-    public final static int REQUEST_BLOCKLIST_ORIGINAL_ENTRY = 5;
-
-    public final static int REQUEST_DEFAULT = 0;
-    public final static int REQUEST_ALLOWED = 1;
-    public final static int REQUEST_THIRD_PARTY = 2;
-    public final static int REQUEST_BLOCKED = 3;
-
-    public final static int MAIN_WHITELIST = 1;
-    public final static int FINAL_WHITELIST = 2;
-    public final static int DOMAIN_WHITELIST = 3;
-    public final static int DOMAIN_INITIAL_WHITELIST = 4;
-    public final static int DOMAIN_FINAL_WHITELIST = 5;
-    public final static int THIRD_PARTY_WHITELIST = 6;
-    public final static int THIRD_PARTY_DOMAIN_WHITELIST = 7;
-    public final static int THIRD_PARTY_DOMAIN_INITIAL_WHITELIST = 8;
-
-    public final static int MAIN_BLACKLIST = 9;
-    public final static int INITIAL_BLACKLIST = 10;
-    public final static int FINAL_BLACKLIST = 11;
-    public final static int DOMAIN_BLACKLIST = 12;
-    public final static int DOMAIN_INITIAL_BLACKLIST = 13;
-    public final static int DOMAIN_FINAL_BLACKLIST = 14;
-    public final static int DOMAIN_REGULAR_EXPRESSION_BLACKLIST = 15;
-    public final static int THIRD_PARTY_BLACKLIST = 16;
-    public final static int THIRD_PARTY_INITIAL_BLACKLIST = 17;
-    public final static int THIRD_PARTY_DOMAIN_BLACKLIST = 18;
-    public final static int THIRD_PARTY_DOMAIN_INITIAL_BLACKLIST = 19;
-    public final static int THIRD_PARTY_REGULAR_EXPRESSION_BLACKLIST = 20;
-    public final static int THIRD_PARTY_DOMAIN_REGULAR_EXPRESSION_BLACKLIST = 21;
-    public final static int REGULAR_EXPRESSION_BLACKLIST = 22;
-
     // `blockAllThirdPartyRequests` is public static so it can be accessed from `RequestsActivity`.
     // It is also used in `onCreate()`, `onPrepareOptionsMenu()`, `onOptionsItemSelected()`, and `applyAppSettings()`
     public static boolean blockAllThirdPartyRequests;
     // `blockAllThirdPartyRequests` is public static so it can be accessed from `RequestsActivity`.
     // It is also used in `onCreate()`, `onPrepareOptionsMenu()`, `onOptionsItemSelected()`, and `applyAppSettings()`
     public static boolean blockAllThirdPartyRequests;
@@ -631,9 +579,6 @@ public class MainWebViewActivity extends AppCompatActivity implements CreateBook
         // Instantiate the block list helper.
         blockListHelper = new BlockListHelper();
 
         // Instantiate the block list helper.
         blockListHelper = new BlockListHelper();
 
-        // Initialize the list of resource requests.
-        resourceRequests = new ArrayList<>();
-
         // Parse the block lists.
         easyList = blockListHelper.parseBlockList(getAssets(), "blocklists/easylist.txt");
         easyPrivacy = blockListHelper.parseBlockList(getAssets(), "blocklists/easyprivacy.txt");
         // Parse the block lists.
         easyList = blockListHelper.parseBlockList(getAssets(), "blocklists/easylist.txt");
         easyPrivacy = blockListHelper.parseBlockList(getAssets(), "blocklists/easyprivacy.txt");
@@ -979,7 +924,7 @@ public class MainWebViewActivity extends AppCompatActivity implements CreateBook
                     navigationBackMenuItem.setEnabled(currentWebView.canGoBack());
                     navigationForwardMenuItem.setEnabled(currentWebView.canGoForward());
                     navigationHistoryMenuItem.setEnabled((currentWebView.canGoBack() || currentWebView.canGoForward()));
                     navigationBackMenuItem.setEnabled(currentWebView.canGoBack());
                     navigationForwardMenuItem.setEnabled(currentWebView.canGoForward());
                     navigationHistoryMenuItem.setEnabled((currentWebView.canGoBack() || currentWebView.canGoForward()));
-                    navigationRequestsMenuItem.setTitle(getString(R.string.requests) + " - " + blockedRequests);
+                    navigationRequestsMenuItem.setTitle(getString(R.string.requests) + " - " + currentWebView.getRequestsCount(NestedScrollWebView.BLOCKED_REQUESTS));
 
                     // Hide the keyboard (if displayed).
                     inputMethodManager.hideSoftInputFromWindow(currentWebView.getWindowToken(), 0);
 
                     // Hide the keyboard (if displayed).
                     inputMethodManager.hideSoftInputFromWindow(currentWebView.getWindowToken(), 0);
@@ -1426,6 +1371,16 @@ public class MainWebViewActivity extends AppCompatActivity implements CreateBook
 
             // Set the status of the display images menu item.
             displayImagesMenuItem.setChecked(currentWebView.getSettings().getLoadsImagesAutomatically());
 
             // Set the status of the display images menu item.
             displayImagesMenuItem.setChecked(currentWebView.getSettings().getLoadsImagesAutomatically());
+
+            // Initialize the display names for the blocklists with the number of blocked requests.
+            blocklistsMenuItem.setTitle(getString(R.string.blocklists) + " - " + currentWebView.getRequestsCount(NestedScrollWebView.BLOCKED_REQUESTS));
+            easyListMenuItem.setTitle(currentWebView.getRequestsCount(NestedScrollWebView.EASY_LIST_BLOCKED_REQUESTS) + " - " + getString(R.string.easylist));
+            easyPrivacyMenuItem.setTitle(currentWebView.getRequestsCount(NestedScrollWebView.EASY_PRIVACY_BLOCKED_REQUESTS) + " - " + getString(R.string.easyprivacy));
+            fanboysAnnoyanceListMenuItem.setTitle(currentWebView.getRequestsCount(NestedScrollWebView.FANBOYS_ANNOYANCE_LIST_BLOCKED_REQUESTS) + " - " + getString(R.string.fanboys_annoyance_list));
+            fanboysSocialBlockingListMenuItem.setTitle(currentWebView.getRequestsCount(NestedScrollWebView.FANBOYS_SOCIAL_BLOCKING_LIST_BLOCKED_REQUESTS) + " - " +
+                    getString(R.string.fanboys_social_blocking_list));
+            ultraPrivacyMenuItem.setTitle(currentWebView.getRequestsCount(NestedScrollWebView.ULTRA_PRIVACY_BLOCKED_REQUESTS) + " - " + getString(R.string.ultraprivacy));
+            blockAllThirdPartyRequestsMenuItem.setTitle(currentWebView.getRequestsCount(NestedScrollWebView.THIRD_PARTY_BLOCKED_REQUESTS) + " - " + getString(R.string.block_all_third_party_requests));
         }
 
         // Set the status of the menu item checkboxes.
         }
 
         // Set the status of the menu item checkboxes.
@@ -1484,15 +1439,6 @@ public class MainWebViewActivity extends AppCompatActivity implements CreateBook
         // Disable Fanboy's Social Blocking List if Fanboy's Annoyance List is checked.
         fanboysSocialBlockingListMenuItem.setEnabled(!fanboysAnnoyanceListEnabled);
 
         // Disable Fanboy's Social Blocking List if Fanboy's Annoyance List is checked.
         fanboysSocialBlockingListMenuItem.setEnabled(!fanboysAnnoyanceListEnabled);
 
-        // Initialize the display names for the blocklists with the number of blocked requests.
-        blocklistsMenuItem.setTitle(getString(R.string.blocklists) + " - " + blockedRequests);
-        easyListMenuItem.setTitle(easyListBlockedRequests + " - " + getString(R.string.easylist));
-        easyPrivacyMenuItem.setTitle(easyPrivacyBlockedRequests + " - " + getString(R.string.easyprivacy));
-        fanboysAnnoyanceListMenuItem.setTitle(fanboysAnnoyanceListBlockedRequests + " - " + getString(R.string.fanboys_annoyance_list));
-        fanboysSocialBlockingListMenuItem.setTitle(fanboysSocialBlockingListBlockedRequests + " - " + getString(R.string.fanboys_social_blocking_list));
-        ultraPrivacyMenuItem.setTitle(ultraPrivacyBlockedRequests + " - " + getString(R.string.ultraprivacy));
-        blockAllThirdPartyRequestsMenuItem.setTitle(thirdPartyBlockedRequests + " - " + getString(R.string.block_all_third_party_requests));
-
         // Select the current user agent menu item.  A switch statement cannot be used because the user agents are not compile time constants.
         if (currentUserAgent.equals(getResources().getStringArray(R.array.user_agent_data)[0])) {  // Privacy Browser.
             menu.findItem(R.id.user_agent_privacy_browser).setChecked(true);
         // Select the current user agent menu item.  A switch statement cannot be used because the user agents are not compile time constants.
         if (currentUserAgent.equals(getResources().getStringArray(R.array.user_agent_data)[0])) {  // Privacy Browser.
             menu.findItem(R.id.user_agent_privacy_browser).setChecked(true);
@@ -2454,8 +2400,13 @@ public class MainWebViewActivity extends AppCompatActivity implements CreateBook
                 break;
 
             case R.id.requests:
                 break;
 
             case R.id.requests:
-                // Launch the requests activity.
+                // Populate the resource requests.
+                RequestsActivity.resourceRequests = currentWebView.getResourceRequests();
+
+                // Create an intent to launch the Requests activity.
                 Intent requestsIntent = new Intent(this, RequestsActivity.class);
                 Intent requestsIntent = new Intent(this, RequestsActivity.class);
+
+                // Make it so.
                 startActivity(requestsIntent);
                 break;
 
                 startActivity(requestsIntent);
                 break;
 
@@ -4905,7 +4856,7 @@ public class MainWebViewActivity extends AppCompatActivity implements CreateBook
                 WebResourceResponse emptyWebResourceResponse = new WebResourceResponse("text/plain", "utf8", new ByteArrayInputStream("".getBytes()));
 
                 // Reset the whitelist results tracker.
                 WebResourceResponse emptyWebResourceResponse = new WebResourceResponse("text/plain", "utf8", new ByteArrayInputStream("".getBytes()));
 
                 // Reset the whitelist results tracker.
-                whiteListResultStringArray = null;
+                String[] whitelistResultStringArray = null;
 
                 // Initialize the third party request tracker.
                 boolean isThirdPartyRequest = false;
 
                 // Initialize the third party request tracker.
                 boolean isThirdPartyRequest = false;
@@ -4945,21 +4896,32 @@ public class MainWebViewActivity extends AppCompatActivity implements CreateBook
                     }
                 }
 
                     }
                 }
 
+                // Get the current WebView page position.
+                int webViewPagePosition = webViewPagerAdapter.getPositionForId(pageId);
+
+                // Determine if the WebView is currently displayed.
+                boolean webViewDisplayed = (webViewPagePosition == tabLayout.getSelectedTabPosition());
+
                 // Block third-party requests if enabled.
                 if (isThirdPartyRequest && blockAllThirdPartyRequests) {
                 // Block third-party requests if enabled.
                 if (isThirdPartyRequest && blockAllThirdPartyRequests) {
+                    // Add the result to the resource requests.
+                    nestedScrollWebView.addResourceRequest(new String[]{BlockListHelper.REQUEST_THIRD_PARTY, url});
+
                     // Increment the blocked requests counters.
                     // Increment the blocked requests counters.
-                    blockedRequests++;
-                    thirdPartyBlockedRequests++;
-
-                    // Update the titles of the blocklist menu items.  This must be run from the UI thread.
-                    activity.runOnUiThread(() -> {
-                        navigationRequestsMenuItem.setTitle(getString(R.string.requests) + " - " + blockedRequests);
-                        blocklistsMenuItem.setTitle(getString(R.string.requests) + " - " + blockedRequests);
-                        blockAllThirdPartyRequestsMenuItem.setTitle(thirdPartyBlockedRequests + " - " + getString(R.string.block_all_third_party_requests));
-                    });
+                    nestedScrollWebView.incrementRequestsCount(NestedScrollWebView.BLOCKED_REQUESTS);
+                    nestedScrollWebView.incrementRequestsCount(NestedScrollWebView.THIRD_PARTY_BLOCKED_REQUESTS);
 
 
-                    // Add the request to the log.
-                    resourceRequests.add(new String[]{String.valueOf(REQUEST_THIRD_PARTY), url});
+                    // Update the titles of the blocklist menu items if the WebView is currently displayed.
+                    if (webViewDisplayed) {
+                        // Updating the UI must be run from the UI thread.
+                        activity.runOnUiThread(() -> {
+                            // Update the menu item titles.
+                            navigationRequestsMenuItem.setTitle(getString(R.string.requests) + " - " + nestedScrollWebView.getRequestsCount(NestedScrollWebView.BLOCKED_REQUESTS));
+                            blocklistsMenuItem.setTitle(getString(R.string.blocklists) + " - " + nestedScrollWebView.getRequestsCount(NestedScrollWebView.BLOCKED_REQUESTS));
+                            blockAllThirdPartyRequestsMenuItem.setTitle(nestedScrollWebView.getRequestsCount(NestedScrollWebView.THIRD_PARTY_BLOCKED_REQUESTS) + " - " +
+                                    getString(R.string.block_all_third_party_requests));
+                        });
+                    }
 
                     // Return an empty web resource response.
                     return emptyWebResourceResponse;
 
                     // Return an empty web resource response.
                     return emptyWebResourceResponse;
@@ -4967,26 +4929,36 @@ public class MainWebViewActivity extends AppCompatActivity implements CreateBook
 
                 // Check UltraPrivacy if it is enabled.
                 if (ultraPrivacyEnabled) {
 
                 // Check UltraPrivacy if it is enabled.
                 if (ultraPrivacyEnabled) {
-                    if (blockListHelper.isBlocked(currentDomain, url, isThirdPartyRequest, ultraPrivacy)) {
-                        // Increment the blocked requests counters.
-                        blockedRequests++;
-                        ultraPrivacyBlockedRequests++;
+                    // Check the URL against UltraPrivacy.
+                    String[] ultraPrivacyResults = blockListHelper.checkBlocklist(currentDomain, url, isThirdPartyRequest, ultraPrivacy);
 
 
-                        // Update the titles of the blocklist menu items.  This must be run from the UI thread.
-                        activity.runOnUiThread(() -> {
-                            navigationRequestsMenuItem.setTitle(getString(R.string.requests) + " - " + blockedRequests);
-                            blocklistsMenuItem.setTitle(getString(R.string.requests) + " - " + blockedRequests);
-                            ultraPrivacyMenuItem.setTitle(ultraPrivacyBlockedRequests + " - " + getString(R.string.ultraprivacy));
-                        });
+                    // Process the UltraPrivacy results.
+                    if (ultraPrivacyResults[0].equals(BlockListHelper.REQUEST_BLOCKED)) {  // The resource request matched UltraPrivacy's blacklist.
+                        // Add the result to the resource requests.
+                        nestedScrollWebView.addResourceRequest(new String[] {ultraPrivacyResults[0], ultraPrivacyResults[1], ultraPrivacyResults[2], ultraPrivacyResults[3], ultraPrivacyResults[4],
+                                ultraPrivacyResults[5]});
+
+                        // Increment the blocked requests counters.
+                        nestedScrollWebView.incrementRequestsCount(NestedScrollWebView.BLOCKED_REQUESTS);
+                        nestedScrollWebView.incrementRequestsCount(NestedScrollWebView.ULTRA_PRIVACY_BLOCKED_REQUESTS);
+
+                        // Update the titles of the blocklist menu items if the WebView is currently displayed.
+                        if (webViewDisplayed) {
+                            // Updating the UI must be run from the UI thread.
+                            activity.runOnUiThread(() -> {
+                                // Update the menu item titles.
+                                navigationRequestsMenuItem.setTitle(getString(R.string.requests) + " - " + nestedScrollWebView.getRequestsCount(NestedScrollWebView.BLOCKED_REQUESTS));
+                                blocklistsMenuItem.setTitle(getString(R.string.blocklists) + " - " + nestedScrollWebView.getRequestsCount(NestedScrollWebView.BLOCKED_REQUESTS));
+                                ultraPrivacyMenuItem.setTitle(nestedScrollWebView.getRequestsCount(NestedScrollWebView.ULTRA_PRIVACY_BLOCKED_REQUESTS) + " - " + getString(R.string.ultraprivacy));
+                            });
+                        }
 
                         // The resource request was blocked.  Return an empty web resource response.
                         return emptyWebResourceResponse;
 
                         // The resource request was blocked.  Return an empty web resource response.
                         return emptyWebResourceResponse;
-                    }
-
-                    // If the whitelist result is not null, the request has been allowed by UltraPrivacy.
-                    if (whiteListResultStringArray != null) {
+                    } else if (ultraPrivacyResults[0].equals(BlockListHelper.REQUEST_ALLOWED)) {  // The resource request matched UltraPrivacy's whitelist.
                         // Add a whitelist entry to the resource requests array.
                         // Add a whitelist entry to the resource requests array.
-                        resourceRequests.add(whiteListResultStringArray);
+                        nestedScrollWebView.addResourceRequest(new String[] {ultraPrivacyResults[0], ultraPrivacyResults[1], ultraPrivacyResults[2], ultraPrivacyResults[3], ultraPrivacyResults[4],
+                                ultraPrivacyResults[5]});
 
                         // The resource request has been allowed by UltraPrivacy.  `return null` loads the requested resource.
                         return null;
 
                         // The resource request has been allowed by UltraPrivacy.  `return null` loads the requested resource.
                         return null;
@@ -4995,94 +4967,145 @@ public class MainWebViewActivity extends AppCompatActivity implements CreateBook
 
                 // Check EasyList if it is enabled.
                 if (easyListEnabled) {
 
                 // Check EasyList if it is enabled.
                 if (easyListEnabled) {
-                    if (blockListHelper.isBlocked(currentDomain, url, isThirdPartyRequest, easyList)) {
-                        // Increment the blocked requests counters.
-                        blockedRequests++;
-                        easyListBlockedRequests++;
+                    // Check the URL against EasyList.
+                    String[] easyListResults = blockListHelper.checkBlocklist(currentDomain, url, isThirdPartyRequest, easyList);
 
 
-                        // Update the titles of the blocklist menu items.  This must be run from the UI thread.
-                        activity.runOnUiThread(() -> {
-                            navigationRequestsMenuItem.setTitle(getString(R.string.requests) + " - " + blockedRequests);
-                            blocklistsMenuItem.setTitle(getString(R.string.requests) + " - " + blockedRequests);
-                            easyListMenuItem.setTitle(easyListBlockedRequests + " - " + getString(R.string.easylist));
-                        });
+                    // Process the EasyList results.
+                    if (easyListResults[0].equals(BlockListHelper.REQUEST_BLOCKED)) {  // The resource request matched EasyList's blacklist.
+                        // Add the result to the resource requests.
+                        nestedScrollWebView.addResourceRequest(new String[] {easyListResults[0], easyListResults[1], easyListResults[2], easyListResults[3], easyListResults[4], easyListResults[5]});
 
 
-                        // Reset the whitelist results tracker (because otherwise it will sometimes add results to the list due to a race condition).
-                        whiteListResultStringArray = null;
+                        // Increment the blocked requests counters.
+                        nestedScrollWebView.incrementRequestsCount(NestedScrollWebView.BLOCKED_REQUESTS);
+                        nestedScrollWebView.incrementRequestsCount(NestedScrollWebView.EASY_LIST_BLOCKED_REQUESTS);
+
+                        // Update the titles of the blocklist menu items if the WebView is currently displayed.
+                        if (webViewDisplayed) {
+                            // Updating the UI must be run from the UI thread.
+                            activity.runOnUiThread(() -> {
+                                // Update the menu item titles.
+                                navigationRequestsMenuItem.setTitle(getString(R.string.requests) + " - " + nestedScrollWebView.getRequestsCount(NestedScrollWebView.BLOCKED_REQUESTS));
+                                blocklistsMenuItem.setTitle(getString(R.string.blocklists) + " - " + nestedScrollWebView.getRequestsCount(NestedScrollWebView.BLOCKED_REQUESTS));
+                                easyListMenuItem.setTitle(nestedScrollWebView.getRequestsCount(NestedScrollWebView.EASY_LIST_BLOCKED_REQUESTS) + " - " + getString(R.string.easylist));
+                            });
+                        }
 
                         // The resource request was blocked.  Return an empty web resource response.
                         return emptyWebResourceResponse;
 
                         // The resource request was blocked.  Return an empty web resource response.
                         return emptyWebResourceResponse;
+                    } else if (easyListResults[0].equals(BlockListHelper.REQUEST_ALLOWED)) {  // The resource request matched EasyList's whitelist.
+                        // Update the whitelist result string array tracker.
+                        whitelistResultStringArray = new String[] {easyListResults[0], easyListResults[1], easyListResults[2], easyListResults[3], easyListResults[4], easyListResults[5]};
                     }
                 }
 
                 // Check EasyPrivacy if it is enabled.
                 if (easyPrivacyEnabled) {
                     }
                 }
 
                 // Check EasyPrivacy if it is enabled.
                 if (easyPrivacyEnabled) {
-                    if (blockListHelper.isBlocked(currentDomain, url, isThirdPartyRequest, easyPrivacy)) {
-                        // Increment the blocked requests counters.
-                        blockedRequests++;
-                        easyPrivacyBlockedRequests++;
+                    // Check the URL against EasyPrivacy.
+                    String[] easyPrivacyResults = blockListHelper.checkBlocklist(currentDomain, url, isThirdPartyRequest, easyPrivacy);
 
 
-                        // Update the titles of the blocklist menu items.  This must be run from the UI thread.
-                        activity.runOnUiThread(() -> {
-                            navigationRequestsMenuItem.setTitle(getString(R.string.requests) + " - " + blockedRequests);
-                            blocklistsMenuItem.setTitle(getString(R.string.requests) + " - " + blockedRequests);
-                            easyPrivacyMenuItem.setTitle(easyPrivacyBlockedRequests + " - " + getString(R.string.easyprivacy));
-                        });
+                    // Process the EasyPrivacy results.
+                    if (easyPrivacyResults[0].equals(BlockListHelper.REQUEST_BLOCKED)) {  // The resource request matched EasyPrivacy's blacklist.
+                        // Add the result to the resource requests.
+                        nestedScrollWebView.addResourceRequest(new String[] {easyPrivacyResults[0], easyPrivacyResults[1], easyPrivacyResults[2], easyPrivacyResults[3], easyPrivacyResults[5],
+                                easyPrivacyResults[5]});
 
 
-                        // Reset the whitelist results tracker (because otherwise it will sometimes add results to the list due to a race condition).
-                        whiteListResultStringArray = null;
+                        // Increment the blocked requests counters.
+                        nestedScrollWebView.incrementRequestsCount(NestedScrollWebView.BLOCKED_REQUESTS);
+                        nestedScrollWebView.incrementRequestsCount(NestedScrollWebView.EASY_PRIVACY_BLOCKED_REQUESTS);
+
+                        // Update the titles of the blocklist menu items if the WebView is currently displayed.
+                        if (webViewDisplayed) {
+                            // Updating the UI must be run from the UI thread.
+                            activity.runOnUiThread(() -> {
+                                // Update the menu item titles.
+                                navigationRequestsMenuItem.setTitle(getString(R.string.requests) + " - " + nestedScrollWebView.getRequestsCount(NestedScrollWebView.BLOCKED_REQUESTS));
+                                blocklistsMenuItem.setTitle(getString(R.string.blocklists) + " - " + nestedScrollWebView.getRequestsCount(NestedScrollWebView.BLOCKED_REQUESTS));
+                                easyPrivacyMenuItem.setTitle(nestedScrollWebView.getRequestsCount(NestedScrollWebView.EASY_PRIVACY_BLOCKED_REQUESTS) + " - " + getString(R.string.easyprivacy));
+                            });
+                        }
 
                         // The resource request was blocked.  Return an empty web resource response.
                         return emptyWebResourceResponse;
 
                         // The resource request was blocked.  Return an empty web resource response.
                         return emptyWebResourceResponse;
+                    } else if (easyPrivacyResults[0].equals(BlockListHelper.REQUEST_ALLOWED)) {  // The resource request matched EasyPrivacy's whitelist.
+                        // Update the whitelist result string array tracker.
+                        whitelistResultStringArray = new String[] {easyPrivacyResults[0], easyPrivacyResults[1], easyPrivacyResults[2], easyPrivacyResults[3], easyPrivacyResults[4], easyPrivacyResults[5]};
                     }
                 }
 
                 // Check Fanboy’s Annoyance List if it is enabled.
                 if (fanboysAnnoyanceListEnabled) {
                     }
                 }
 
                 // Check Fanboy’s Annoyance List if it is enabled.
                 if (fanboysAnnoyanceListEnabled) {
-                    if (blockListHelper.isBlocked(currentDomain, url, isThirdPartyRequest, fanboysAnnoyanceList)) {
-                        // Increment the blocked requests counters.
-                        blockedRequests++;
-                        fanboysAnnoyanceListBlockedRequests++;
+                    // Check the URL against Fanboy's Annoyance List.
+                    String[] fanboysAnnoyanceListResults = blockListHelper.checkBlocklist(currentDomain, url, isThirdPartyRequest, fanboysAnnoyanceList);
 
 
-                        // Update the titles of the blocklist menu items.  This must be run from the UI thread.
-                        activity.runOnUiThread(() -> {
-                            navigationRequestsMenuItem.setTitle(getString(R.string.requests) + " - " + blockedRequests);
-                            blocklistsMenuItem.setTitle(getString(R.string.requests) + " - " + blockedRequests);
-                            fanboysAnnoyanceListMenuItem.setTitle(fanboysAnnoyanceListBlockedRequests + " - " + getString(R.string.fanboys_annoyance_list));
-                        });
+                    // Process the Fanboy's Annoyance List results.
+                    if (fanboysAnnoyanceListResults[0].equals(BlockListHelper.REQUEST_BLOCKED)) {  // The resource request matched Fanboy's Annoyance List's blacklist.
+                        // Add the result to the resource requests.
+                        nestedScrollWebView.addResourceRequest(new String[] {fanboysAnnoyanceListResults[0], fanboysAnnoyanceListResults[1], fanboysAnnoyanceListResults[2], fanboysAnnoyanceListResults[3],
+                                fanboysAnnoyanceListResults[4], fanboysAnnoyanceListResults[5]});
 
 
-                        // Reset the whitelist results tracker (because otherwise it will sometimes add results to the list due to a race condition).
-                        whiteListResultStringArray = null;
+                        // Increment the blocked requests counters.
+                        nestedScrollWebView.incrementRequestsCount(NestedScrollWebView.BLOCKED_REQUESTS);
+                        nestedScrollWebView.incrementRequestsCount(NestedScrollWebView.FANBOYS_ANNOYANCE_LIST_BLOCKED_REQUESTS);
+
+                        // Update the titles of the blocklist menu items if the WebView is currently displayed.
+                        if (webViewDisplayed) {
+                            // Updating the UI must be run from the UI thread.
+                            activity.runOnUiThread(() -> {
+                                // Update the menu item titles.
+                                navigationRequestsMenuItem.setTitle(getString(R.string.requests) + " - " + nestedScrollWebView.getRequestsCount(NestedScrollWebView.BLOCKED_REQUESTS));
+                                blocklistsMenuItem.setTitle(getString(R.string.blocklists) + " - " + nestedScrollWebView.getRequestsCount(NestedScrollWebView.BLOCKED_REQUESTS));
+                                fanboysAnnoyanceListMenuItem.setTitle(nestedScrollWebView.getRequestsCount(NestedScrollWebView.FANBOYS_ANNOYANCE_LIST_BLOCKED_REQUESTS) + " - " +
+                                        getString(R.string.fanboys_annoyance_list));
+                            });
+                        }
 
                         // The resource request was blocked.  Return an empty web resource response.
                         return emptyWebResourceResponse;
 
                         // The resource request was blocked.  Return an empty web resource response.
                         return emptyWebResourceResponse;
+                    } else if (fanboysAnnoyanceListResults[0].equals(BlockListHelper.REQUEST_ALLOWED)){  // The resource request matched Fanboy's Annoyance List's whitelist.
+                        // Update the whitelist result string array tracker.
+                        whitelistResultStringArray = new String[] {fanboysAnnoyanceListResults[0], fanboysAnnoyanceListResults[1], fanboysAnnoyanceListResults[2], fanboysAnnoyanceListResults[3],
+                                fanboysAnnoyanceListResults[4], fanboysAnnoyanceListResults[5]};
                     }
                 } else if (fanboysSocialBlockingListEnabled) {  // Only check Fanboy’s Social Blocking List if Fanboy’s Annoyance List is disabled.
                     }
                 } else if (fanboysSocialBlockingListEnabled) {  // Only check Fanboy’s Social Blocking List if Fanboy’s Annoyance List is disabled.
-                    if (blockListHelper.isBlocked(currentDomain, url, isThirdPartyRequest, fanboysSocialList)) {
-                        // Increment the blocked requests counters.
-                        blockedRequests++;
-                        fanboysSocialBlockingListBlockedRequests++;
+                    // Check the URL against Fanboy's Annoyance List.
+                    String[] fanboysSocialListResults = blockListHelper.checkBlocklist(currentDomain, url, isThirdPartyRequest, fanboysSocialList);
 
 
-                        // Update the titles of the blocklist menu items.  This must be run from the UI thread.
-                        activity.runOnUiThread(() -> {
-                            navigationRequestsMenuItem.setTitle(getString(R.string.requests) + " - " + blockedRequests);
-                            blocklistsMenuItem.setTitle(getString(R.string.requests) + " - " + blockedRequests);
-                            fanboysSocialBlockingListMenuItem.setTitle(fanboysSocialBlockingListBlockedRequests + " - " + getString(R.string.fanboys_social_blocking_list));
-                        });
+                    // Process the Fanboy's Social Blocking List results.
+                    if (fanboysSocialListResults[0].equals(BlockListHelper.REQUEST_BLOCKED)) {  // The resource request matched Fanboy's Social Blocking List's blacklist.
+                        // Add the result to the resource requests.
+                        nestedScrollWebView.addResourceRequest(new String[] {fanboysSocialListResults[0], fanboysSocialListResults[1], fanboysSocialListResults[2], fanboysSocialListResults[3],
+                                fanboysSocialListResults[4], fanboysSocialListResults[5]});
 
 
-                        // Reset the whitelist results tracker (because otherwise it will sometimes add results to the list due to a race condition).
-                        whiteListResultStringArray = null;
+                        // Increment the blocked requests counters.
+                        nestedScrollWebView.incrementRequestsCount(NestedScrollWebView.BLOCKED_REQUESTS);
+                        nestedScrollWebView.incrementRequestsCount(NestedScrollWebView.FANBOYS_SOCIAL_BLOCKING_LIST_BLOCKED_REQUESTS);
+
+                        // Update the titles of the blocklist menu items if the WebView is currently displayed.
+                        if (webViewDisplayed) {
+                            // Updating the UI must be run from the UI thread.
+                            activity.runOnUiThread(() -> {
+                                // Update the menu item titles.
+                                navigationRequestsMenuItem.setTitle(getString(R.string.requests) + " - " + nestedScrollWebView.getRequestsCount(NestedScrollWebView.BLOCKED_REQUESTS));
+                                blocklistsMenuItem.setTitle(getString(R.string.blocklists) + " - " + nestedScrollWebView.getRequestsCount(NestedScrollWebView.BLOCKED_REQUESTS));
+                                fanboysSocialBlockingListMenuItem.setTitle(nestedScrollWebView.getRequestsCount(NestedScrollWebView.FANBOYS_SOCIAL_BLOCKING_LIST_BLOCKED_REQUESTS) + " - " +
+                                        getString(R.string.fanboys_social_blocking_list));
+                            });
+                        }
 
                         // The resource request was blocked.  Return an empty web resource response.
                         return emptyWebResourceResponse;
 
                         // The resource request was blocked.  Return an empty web resource response.
                         return emptyWebResourceResponse;
+                    } else if (fanboysSocialListResults[0].equals(BlockListHelper.REQUEST_ALLOWED)) {  // The resource request matched Fanboy's Social Blocking List's whitelist.
+                        // Update the whitelist result string array tracker.
+                        whitelistResultStringArray = new String[] {fanboysSocialListResults[0], fanboysSocialListResults[1], fanboysSocialListResults[2], fanboysSocialListResults[3],
+                                fanboysSocialListResults[4], fanboysSocialListResults[5]};
                     }
                 }
 
                 // Add the request to the log because it hasn't been processed by any of the previous checks.
                     }
                 }
 
                 // Add the request to the log because it hasn't been processed by any of the previous checks.
-                if (whiteListResultStringArray != null) {  // The request was processed by a whitelist.
-                    resourceRequests.add(whiteListResultStringArray);
+                if (whitelistResultStringArray != null) {  // The request was processed by a whitelist.
+                    nestedScrollWebView.addResourceRequest(whitelistResultStringArray);
                 } else {  // The request didn't match any blocklist entry.  Log it as a default request.
                 } else {  // The request didn't match any blocklist entry.  Log it as a default request.
-                    resourceRequests.add(new String[]{String.valueOf(REQUEST_DEFAULT), url});
+                    nestedScrollWebView.addResourceRequest(new String[]{BlockListHelper.REQUEST_DEFAULT, url});
                 }
 
                 // The resource request has not been blocked.  `return null` loads the requested resource.
                 }
 
                 // The resource request has not been blocked.  `return null` loads the requested resource.
@@ -5111,16 +5134,16 @@ public class MainWebViewActivity extends AppCompatActivity implements CreateBook
                 currentHostIpAddresses = "";
 
                 // Reset the list of resource requests.
                 currentHostIpAddresses = "";
 
                 // Reset the list of resource requests.
-                resourceRequests.clear();
+                nestedScrollWebView.clearResourceRequests();
 
                 // Initialize the counters for requests blocked by each blocklist.
 
                 // Initialize the counters for requests blocked by each blocklist.
-                blockedRequests = 0;
-                easyListBlockedRequests = 0;
-                easyPrivacyBlockedRequests = 0;
-                fanboysAnnoyanceListBlockedRequests = 0;
-                fanboysSocialBlockingListBlockedRequests = 0;
-                ultraPrivacyBlockedRequests = 0;
-                thirdPartyBlockedRequests = 0;
+                nestedScrollWebView.resetRequestsCount(NestedScrollWebView.BLOCKED_REQUESTS);
+                nestedScrollWebView.resetRequestsCount(NestedScrollWebView.EASY_LIST_BLOCKED_REQUESTS);
+                nestedScrollWebView.resetRequestsCount(NestedScrollWebView.EASY_PRIVACY_BLOCKED_REQUESTS);
+                nestedScrollWebView.resetRequestsCount(NestedScrollWebView.FANBOYS_ANNOYANCE_LIST_BLOCKED_REQUESTS);
+                nestedScrollWebView.resetRequestsCount(NestedScrollWebView.FANBOYS_SOCIAL_BLOCKING_LIST_BLOCKED_REQUESTS);
+                nestedScrollWebView.resetRequestsCount(NestedScrollWebView.ULTRA_PRIVACY_BLOCKED_REQUESTS);
+                nestedScrollWebView.resetRequestsCount(NestedScrollWebView.THIRD_PARTY_BLOCKED_REQUESTS);
 
                 // If night mode is enabled, hide `mainWebView` until after the night mode CSS is applied.
                 if (nightMode) {
 
                 // If night mode is enabled, hide `mainWebView` until after the night mode CSS is applied.
                 if (nightMode) {
index 4c42db79f13af2eccf8e842c03fd52d8a26d35f1..4d2201be6e1ee750167575b4fcec317e09c6bed2 100644 (file)
 package com.stoutner.privacybrowser.activities;
 
 import android.content.Context;
 package com.stoutner.privacybrowser.activities;
 
 import android.content.Context;
+import android.content.SharedPreferences;
 import android.database.Cursor;
 import android.database.MatrixCursor;
 import android.os.Bundle;
 import android.database.Cursor;
 import android.database.MatrixCursor;
 import android.os.Bundle;
+import android.preference.PreferenceManager;
 import android.view.View;
 import android.view.WindowManager;
 import android.widget.AdapterView;
 import android.view.View;
 import android.view.WindowManager;
 import android.widget.AdapterView;
@@ -40,23 +42,34 @@ import androidx.fragment.app.DialogFragment;
 import com.stoutner.privacybrowser.R;
 import com.stoutner.privacybrowser.adapters.RequestsArrayAdapter;
 import com.stoutner.privacybrowser.dialogs.ViewRequestDialog;
 import com.stoutner.privacybrowser.R;
 import com.stoutner.privacybrowser.adapters.RequestsArrayAdapter;
 import com.stoutner.privacybrowser.dialogs.ViewRequestDialog;
+import com.stoutner.privacybrowser.helpers.BlockListHelper;
 
 import java.util.ArrayList;
 import java.util.List;
 
 public class RequestsActivity extends AppCompatActivity implements ViewRequestDialog.ViewRequestListener {
 
 import java.util.ArrayList;
 import java.util.List;
 
 public class RequestsActivity extends AppCompatActivity implements ViewRequestDialog.ViewRequestListener {
+    // The resource requests are populated by `MainWebViewActivity` before `RequestsActivity` is launched.
+    public static ArrayList<String[]> resourceRequests;
+
     // The list view is used in `onCreate()` and `launchViewRequestDialog()`.
     private ListView requestsListView;
 
     @Override
     public void onCreate(Bundle savedInstanceState) {
     // The list view is used in `onCreate()` and `launchViewRequestDialog()`.
     private ListView requestsListView;
 
     @Override
     public void onCreate(Bundle savedInstanceState) {
+        // Get a handle for the shared preferences.
+        SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(getApplicationContext());
+
+        // Get the screenshot and theme preferences.
+        boolean allowScreenshots = sharedPreferences.getBoolean("allow_screenshots", false);
+        boolean darkTheme = sharedPreferences.getBoolean("dark_theme", false);
+
         // Disable screenshots if not allowed.
         // Disable screenshots if not allowed.
-        if (!MainWebViewActivity.allowScreenshots) {
+        if (!allowScreenshots) {
             getWindow().addFlags(WindowManager.LayoutParams.FLAG_SECURE);
         }
 
         // Set the activity theme.
             getWindow().addFlags(WindowManager.LayoutParams.FLAG_SECURE);
         }
 
         // Set the activity theme.
-        if (MainWebViewActivity.darkTheme) {
+        if (darkTheme) {
             setTheme(R.style.PrivacyBrowserDark_SecondaryActivity);
         } else {
             setTheme(R.style.PrivacyBrowserLight_SecondaryActivity);
             setTheme(R.style.PrivacyBrowserDark_SecondaryActivity);
         } else {
             setTheme(R.style.PrivacyBrowserLight_SecondaryActivity);
@@ -68,7 +81,7 @@ public class RequestsActivity extends AppCompatActivity implements ViewRequestDi
         // Set the content view.
         setContentView(R.layout.requests_coordinatorlayout);
 
         // Set the content view.
         setContentView(R.layout.requests_coordinatorlayout);
 
-        // Use the AndroidX toolbar from until the minimum API is >= 21.
+        // Use the AndroidX toolbar until the minimum API is >= 21.
         Toolbar toolbar = findViewById(R.id.requests_toolbar);
         setSupportActionBar(toolbar);
 
         Toolbar toolbar = findViewById(R.id.requests_toolbar);
         setSupportActionBar(toolbar);
 
@@ -91,9 +104,9 @@ public class RequestsActivity extends AppCompatActivity implements ViewRequestDi
         List<String[]> blockedResourceRequests = new ArrayList<>();
 
         // Populate the resource array lists.
         List<String[]> blockedResourceRequests = new ArrayList<>();
 
         // Populate the resource array lists.
-        for (String[] request : MainWebViewActivity.resourceRequests) {
-            switch (Integer.valueOf(request[MainWebViewActivity.REQUEST_DISPOSITION])) {
-                case MainWebViewActivity.REQUEST_DEFAULT:
+        for (String[] request : resourceRequests) {
+            switch (request[BlockListHelper.REQUEST_DISPOSITION]) {
+                case BlockListHelper.REQUEST_DEFAULT:
                     // Add the request to the list of all requests.
                     allResourceRequests.add(request);
 
                     // Add the request to the list of all requests.
                     allResourceRequests.add(request);
 
@@ -101,7 +114,7 @@ public class RequestsActivity extends AppCompatActivity implements ViewRequestDi
                     defaultResourceRequests.add(request);
                     break;
 
                     defaultResourceRequests.add(request);
                     break;
 
-                case MainWebViewActivity.REQUEST_ALLOWED:
+                case BlockListHelper.REQUEST_ALLOWED:
                     // Add the request to the list of all requests.
                     allResourceRequests.add(request);
 
                     // Add the request to the list of all requests.
                     allResourceRequests.add(request);
 
@@ -109,7 +122,7 @@ public class RequestsActivity extends AppCompatActivity implements ViewRequestDi
                     allowedResourceRequests.add(request);
                     break;
 
                     allowedResourceRequests.add(request);
                     break;
 
-                case MainWebViewActivity.REQUEST_THIRD_PARTY:
+                case BlockListHelper.REQUEST_THIRD_PARTY:
                     // Add the request to the list of all requests.
                     allResourceRequests.add(request);
 
                     // Add the request to the list of all requests.
                     allResourceRequests.add(request);
 
@@ -117,7 +130,7 @@ public class RequestsActivity extends AppCompatActivity implements ViewRequestDi
                     thirdPartyResourceRequests.add(request);
                     break;
 
                     thirdPartyResourceRequests.add(request);
                     break;
 
-                case MainWebViewActivity.REQUEST_BLOCKED:
+                case BlockListHelper.REQUEST_BLOCKED:
                     // Add the request to the list of all requests.
                     allResourceRequests.add(request);
 
                     // Add the request to the list of all requests.
                     allResourceRequests.add(request);
 
index f6f1e8b45b6afcae0849263a21ba917a1b2643f0..5bb6b0a4033bae5ce07511977532eaa2adada42a 100644 (file)
@@ -20,6 +20,8 @@
 package com.stoutner.privacybrowser.adapters;
 
 import android.content.Context;
 package com.stoutner.privacybrowser.adapters;
 
 import android.content.Context;
+import android.content.SharedPreferences;
+import android.preference.PreferenceManager;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
@@ -30,7 +32,7 @@ import android.widget.TextView;
 import androidx.annotation.NonNull;
 
 import com.stoutner.privacybrowser.R;
 import androidx.annotation.NonNull;
 
 import com.stoutner.privacybrowser.R;
-import com.stoutner.privacybrowser.activities.MainWebViewActivity;
+import com.stoutner.privacybrowser.helpers.BlockListHelper;
 
 import java.util.List;
 
 
 import java.util.List;
 
@@ -43,6 +45,12 @@ public class RequestsArrayAdapter extends ArrayAdapter<String[]> {
     @Override
     @NonNull
     public View getView(int position, View view, @NonNull ViewGroup parent) {
     @Override
     @NonNull
     public View getView(int position, View view, @NonNull ViewGroup parent) {
+        // Get a handle for the shared preferences.
+        SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(getContext());
+
+        // Get the theme preferences.
+        boolean darkTheme = sharedPreferences.getBoolean("dark_theme", false);
+
         // Get a handle for the context.
         Context context = getContext();
 
         // Get a handle for the context.
         Context context = getContext();
 
@@ -66,8 +74,8 @@ public class RequestsArrayAdapter extends ArrayAdapter<String[]> {
         int id = position + 1;
 
         // Set the action text and the background color.
         int id = position + 1;
 
         // Set the action text and the background color.
-        switch (Integer.valueOf(entryStringArray[0])) {
-            case MainWebViewActivity.REQUEST_DEFAULT:
+        switch (entryStringArray[0]) {
+            case BlockListHelper.REQUEST_DEFAULT:
                 // Create the disposition string.
                 String requestDefault = id + ". " + context.getResources().getString(R.string.allowed);
 
                 // Create the disposition string.
                 String requestDefault = id + ". " + context.getResources().getString(R.string.allowed);
 
@@ -78,7 +86,7 @@ public class RequestsArrayAdapter extends ArrayAdapter<String[]> {
                 linearLayout.setBackgroundColor(context.getResources().getColor(R.color.transparent));
                 break;
 
                 linearLayout.setBackgroundColor(context.getResources().getColor(R.color.transparent));
                 break;
 
-            case MainWebViewActivity.REQUEST_ALLOWED:
+            case BlockListHelper.REQUEST_ALLOWED:
                 // Create the disposition string.
                 String requestAllowed = id + ". " + context.getResources().getString(R.string.allowed);
 
                 // Create the disposition string.
                 String requestAllowed = id + ". " + context.getResources().getString(R.string.allowed);
 
@@ -86,14 +94,14 @@ public class RequestsArrayAdapter extends ArrayAdapter<String[]> {
                 dispositionTextView.setText(requestAllowed);
 
                 // Set the background color.
                 dispositionTextView.setText(requestAllowed);
 
                 // Set the background color.
-                if (MainWebViewActivity.darkTheme) {
+                if (darkTheme) {
                     linearLayout.setBackgroundColor(context.getResources().getColor(R.color.blue_700_50));
                 } else {
                     linearLayout.setBackgroundColor(context.getResources().getColor(R.color.blue_100));
                 }
                 break;
 
                     linearLayout.setBackgroundColor(context.getResources().getColor(R.color.blue_700_50));
                 } else {
                     linearLayout.setBackgroundColor(context.getResources().getColor(R.color.blue_100));
                 }
                 break;
 
-            case MainWebViewActivity.REQUEST_THIRD_PARTY:
+            case BlockListHelper.REQUEST_THIRD_PARTY:
                 // Create the disposition string.
                 String requestThirdParty = id + ". " + context.getResources().getString(R.string.blocked);
 
                 // Create the disposition string.
                 String requestThirdParty = id + ". " + context.getResources().getString(R.string.blocked);
 
@@ -101,7 +109,7 @@ public class RequestsArrayAdapter extends ArrayAdapter<String[]> {
                 dispositionTextView.setText(requestThirdParty);
 
                 // Set the background color.
                 dispositionTextView.setText(requestThirdParty);
 
                 // Set the background color.
-                if (MainWebViewActivity.darkTheme) {
+                if (darkTheme) {
                     linearLayout.setBackgroundColor(context.getResources().getColor(R.color.yellow_700_50));
                 } else {
                     linearLayout.setBackgroundColor(context.getResources().getColor(R.color.yellow_100));
                     linearLayout.setBackgroundColor(context.getResources().getColor(R.color.yellow_700_50));
                 } else {
                     linearLayout.setBackgroundColor(context.getResources().getColor(R.color.yellow_100));
@@ -109,7 +117,7 @@ public class RequestsArrayAdapter extends ArrayAdapter<String[]> {
                 break;
 
 
                 break;
 
 
-            case MainWebViewActivity.REQUEST_BLOCKED:
+            case BlockListHelper.REQUEST_BLOCKED:
                 // Create the disposition string.
                 String requestBlocked = id + ". " + context.getResources().getString(R.string.blocked);
 
                 // Create the disposition string.
                 String requestBlocked = id + ". " + context.getResources().getString(R.string.blocked);
 
@@ -117,7 +125,7 @@ public class RequestsArrayAdapter extends ArrayAdapter<String[]> {
                 dispositionTextView.setText(requestBlocked);
 
                 // Set the background color.
                 dispositionTextView.setText(requestBlocked);
 
                 // Set the background color.
-                if (MainWebViewActivity.darkTheme) {
+                if (darkTheme) {
                     linearLayout.setBackgroundColor(context.getResources().getColor(R.color.red_700_40));
                 } else {
                     linearLayout.setBackgroundColor(context.getResources().getColor(R.color.red_100));
                     linearLayout.setBackgroundColor(context.getResources().getColor(R.color.red_700_40));
                 } else {
                     linearLayout.setBackgroundColor(context.getResources().getColor(R.color.red_100));
@@ -129,7 +137,7 @@ public class RequestsArrayAdapter extends ArrayAdapter<String[]> {
         urlTextView.setText(entryStringArray[1]);
 
         // Set the text color.  For some unexplained reason, `android:textColor="?android:textColorPrimary"` doesn't work in the layout file.  Probably some bug relating to array adapters.
         urlTextView.setText(entryStringArray[1]);
 
         // Set the text color.  For some unexplained reason, `android:textColor="?android:textColorPrimary"` doesn't work in the layout file.  Probably some bug relating to array adapters.
-        if (MainWebViewActivity.darkTheme) {
+        if (darkTheme) {
             dispositionTextView.setTextColor(context.getResources().getColor(R.color.gray_200));
             urlTextView.setTextColor(context.getResources().getColor(R.color.gray_200));
         } else {
             dispositionTextView.setTextColor(context.getResources().getColor(R.color.gray_200));
             urlTextView.setTextColor(context.getResources().getColor(R.color.gray_200));
         } else {
@@ -140,4 +148,4 @@ public class RequestsArrayAdapter extends ArrayAdapter<String[]> {
         // Return the modified view.
         return view;
     }
         // Return the modified view.
         return view;
     }
-}
+}
\ No newline at end of file
index 6d6401f3af24428ea0f6e457d33c39ac817ff3fb..fd8d68e12895393d5308fd6dc6040d610ac8aa06 100644 (file)
@@ -24,7 +24,9 @@ import android.app.AlertDialog;
 import android.app.Dialog;
 import android.content.Context;
 import android.content.DialogInterface;
 import android.app.Dialog;
 import android.content.Context;
 import android.content.DialogInterface;
+import android.content.SharedPreferences;
 import android.os.Bundle;
 import android.os.Bundle;
+import android.preference.PreferenceManager;
 import android.view.View;
 import android.view.WindowManager;
 import android.widget.Button;
 import android.view.View;
 import android.view.WindowManager;
 import android.widget.Button;
@@ -34,7 +36,7 @@ import androidx.annotation.NonNull;
 import androidx.fragment.app.DialogFragment;
 
 import com.stoutner.privacybrowser.R;
 import androidx.fragment.app.DialogFragment;
 
 import com.stoutner.privacybrowser.R;
-import com.stoutner.privacybrowser.activities.MainWebViewActivity;
+import com.stoutner.privacybrowser.helpers.BlockListHelper;
 
 public class ViewRequestDialog extends DialogFragment {
     // The public interface is used to send information back to the parent activity.
 
 public class ViewRequestDialog extends DialogFragment {
     // The public interface is used to send information back to the parent activity.
@@ -77,6 +79,13 @@ public class ViewRequestDialog extends DialogFragment {
     // `@SuppressLing("InflateParams")` removes the warning about using `null` as the parent view group when inflating the `AlertDialog`.
     @SuppressLint("InflateParams")
     public Dialog onCreateDialog(Bundle savedInstanceState) {
     // `@SuppressLing("InflateParams")` removes the warning about using `null` as the parent view group when inflating the `AlertDialog`.
     @SuppressLint("InflateParams")
     public Dialog onCreateDialog(Bundle savedInstanceState) {
+        // Get a handle for the shared preferences.
+        SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(getContext());
+
+        // Get the theme and screenshot preferences.
+        boolean darkTheme = sharedPreferences.getBoolean("dark_theme", false);
+        boolean allowScreenshots = sharedPreferences.getBoolean("allow_screenshots", false);
+
         // Remove the incorrect lint warning that `getInt()` might be null.
         assert getArguments() != null;
 
         // Remove the incorrect lint warning that `getInt()` might be null.
         assert getArguments() != null;
 
@@ -89,7 +98,7 @@ public class ViewRequestDialog extends DialogFragment {
         AlertDialog.Builder dialogBuilder;
 
         // Set the style and icon according to the theme.
         AlertDialog.Builder dialogBuilder;
 
         // Set the style and icon according to the theme.
-        if (MainWebViewActivity.darkTheme) {
+        if (darkTheme) {
             dialogBuilder = new AlertDialog.Builder(getActivity(), R.style.PrivacyBrowserAlertDialogDark);
             dialogBuilder.setIcon(R.drawable.block_ads_enabled_dark);
         } else {
             dialogBuilder = new AlertDialog.Builder(getActivity(), R.style.PrivacyBrowserAlertDialogDark);
             dialogBuilder.setIcon(R.drawable.block_ads_enabled_dark);
         } else {
@@ -131,7 +140,7 @@ public class ViewRequestDialog extends DialogFragment {
         final AlertDialog alertDialog = dialogBuilder.create();
 
         // Disable screenshots if not allowed.
         final AlertDialog alertDialog = dialogBuilder.create();
 
         // Disable screenshots if not allowed.
-        if (!MainWebViewActivity.allowScreenshots) {
+        if (!allowScreenshots) {
             // Remove the warning below that `getWindow()` might be null.
             assert alertDialog.getWindow() != null;
 
             // Remove the warning below that `getWindow()` might be null.
             assert alertDialog.getWindow() != null;
 
@@ -163,8 +172,8 @@ public class ViewRequestDialog extends DialogFragment {
         nextButton.setEnabled(!isLastRequest);
 
         // Set the request action text.
         nextButton.setEnabled(!isLastRequest);
 
         // Set the request action text.
-        switch (Integer.valueOf(requestDetails[MainWebViewActivity.REQUEST_DISPOSITION])) {
-            case MainWebViewActivity.REQUEST_DEFAULT:
+        switch (requestDetails[BlockListHelper.REQUEST_DISPOSITION]) {
+            case BlockListHelper.REQUEST_DEFAULT:
                 // Set the text.
                 requestDisposition.setText(R.string.default_allowed);
 
                 // Set the text.
                 requestDisposition.setText(R.string.default_allowed);
 
@@ -172,36 +181,36 @@ public class ViewRequestDialog extends DialogFragment {
                 requestDisposition.setBackgroundColor(getResources().getColor(R.color.transparent));
                 break;
 
                 requestDisposition.setBackgroundColor(getResources().getColor(R.color.transparent));
                 break;
 
-            case MainWebViewActivity.REQUEST_ALLOWED:
+            case BlockListHelper.REQUEST_ALLOWED:
                 // Set the text.
                 requestDisposition.setText(R.string.allowed);
 
                 // Set the background color.
                 // Set the text.
                 requestDisposition.setText(R.string.allowed);
 
                 // Set the background color.
-                if (MainWebViewActivity.darkTheme) {
+                if (darkTheme) {
                     requestDisposition.setBackgroundColor(getResources().getColor(R.color.blue_700_50));
                 } else {
                     requestDisposition.setBackgroundColor(getResources().getColor(R.color.blue_100));
                 }
                 break;
 
                     requestDisposition.setBackgroundColor(getResources().getColor(R.color.blue_700_50));
                 } else {
                     requestDisposition.setBackgroundColor(getResources().getColor(R.color.blue_100));
                 }
                 break;
 
-            case MainWebViewActivity.REQUEST_THIRD_PARTY:
+            case BlockListHelper.REQUEST_THIRD_PARTY:
                 // Set the text.
                 requestDisposition.setText(R.string.third_party_blocked);
 
                 // Set the background color.
                 // Set the text.
                 requestDisposition.setText(R.string.third_party_blocked);
 
                 // Set the background color.
-                if (MainWebViewActivity.darkTheme) {
+                if (darkTheme) {
                     requestDisposition.setBackgroundColor(getResources().getColor(R.color.yellow_700_50));
                 } else {
                     requestDisposition.setBackgroundColor(getResources().getColor(R.color.yellow_100));
                 }
                 break;
 
                     requestDisposition.setBackgroundColor(getResources().getColor(R.color.yellow_700_50));
                 } else {
                     requestDisposition.setBackgroundColor(getResources().getColor(R.color.yellow_100));
                 }
                 break;
 
-            case MainWebViewActivity.REQUEST_BLOCKED:
+            case BlockListHelper.REQUEST_BLOCKED:
                 // Set the text.
                 requestDisposition.setText(R.string.blocked);
 
                 // Set the background color.
                 // Set the text.
                 requestDisposition.setText(R.string.blocked);
 
                 // Set the background color.
-                if (MainWebViewActivity.darkTheme) {
+                if (darkTheme) {
                     requestDisposition.setBackgroundColor(getResources().getColor(R.color.red_700_40));
                 } else {
                     requestDisposition.setBackgroundColor(getResources().getColor(R.color.red_100));
                     requestDisposition.setBackgroundColor(getResources().getColor(R.color.red_700_40));
                 } else {
                     requestDisposition.setBackgroundColor(getResources().getColor(R.color.red_100));
@@ -210,7 +219,7 @@ public class ViewRequestDialog extends DialogFragment {
         }
 
         // Display the request URL.
         }
 
         // Display the request URL.
-        requestUrl.setText(requestDetails[MainWebViewActivity.REQUEST_URL]);
+        requestUrl.setText(requestDetails[BlockListHelper.REQUEST_URL]);
 
         // Modify the dialog based on the request action.
         if (requestDetails.length == 2) {  // A default request.
 
         // Modify the dialog based on the request action.
         if (requestDetails.length == 2) {  // A default request.
@@ -225,93 +234,97 @@ public class ViewRequestDialog extends DialogFragment {
             requestBlockListOriginalEntry.setVisibility(View.GONE);
         } else {  // A blocked or allowed request.
             // Set the text on the text views.
             requestBlockListOriginalEntry.setVisibility(View.GONE);
         } else {  // A blocked or allowed request.
             // Set the text on the text views.
-            requestBlockList.setText(requestDetails[MainWebViewActivity.REQUEST_BLOCKLIST]);
-            requestBlockListEntries.setText(requestDetails[MainWebViewActivity.REQUEST_BLOCKLIST_ENTRIES]);
-            requestBlockListOriginalEntry.setText(requestDetails[MainWebViewActivity.REQUEST_BLOCKLIST_ORIGINAL_ENTRY]);
+            requestBlockList.setText(requestDetails[BlockListHelper.REQUEST_BLOCKLIST]);
+            requestBlockListEntries.setText(requestDetails[BlockListHelper.REQUEST_BLOCKLIST_ENTRIES]);
+            requestBlockListOriginalEntry.setText(requestDetails[BlockListHelper.REQUEST_BLOCKLIST_ORIGINAL_ENTRY]);
 
             // Set the sublist text.
 
             // Set the sublist text.
-            switch (Integer.valueOf(requestDetails[MainWebViewActivity.REQUEST_SUBLIST])) {
-                case MainWebViewActivity.MAIN_WHITELIST:
+            switch (requestDetails[BlockListHelper.REQUEST_SUBLIST]) {
+                case BlockListHelper.MAIN_WHITELIST:
                     requestSubList.setText(R.string.main_whitelist);
                     break;
 
                     requestSubList.setText(R.string.main_whitelist);
                     break;
 
-                case MainWebViewActivity.FINAL_WHITELIST:
+                case BlockListHelper.FINAL_WHITELIST:
                     requestSubList.setText(R.string.final_whitelist);
                     break;
 
                     requestSubList.setText(R.string.final_whitelist);
                     break;
 
-                case MainWebViewActivity.DOMAIN_WHITELIST:
+                case BlockListHelper.DOMAIN_WHITELIST:
                     requestSubList.setText(R.string.domain_whitelist);
                     break;
 
                     requestSubList.setText(R.string.domain_whitelist);
                     break;
 
-                case MainWebViewActivity.DOMAIN_INITIAL_WHITELIST:
+                case BlockListHelper.DOMAIN_INITIAL_WHITELIST:
                     requestSubList.setText(R.string.domain_initial_whitelist);
                     break;
 
                     requestSubList.setText(R.string.domain_initial_whitelist);
                     break;
 
-                case MainWebViewActivity.DOMAIN_FINAL_WHITELIST:
+                case BlockListHelper.DOMAIN_FINAL_WHITELIST:
                     requestSubList.setText(R.string.domain_final_whitelist);
                     break;
 
                     requestSubList.setText(R.string.domain_final_whitelist);
                     break;
 
-                case MainWebViewActivity.THIRD_PARTY_WHITELIST:
+                case BlockListHelper.THIRD_PARTY_WHITELIST:
                     requestSubList.setText(R.string.third_party_whitelist);
                     break;
 
                     requestSubList.setText(R.string.third_party_whitelist);
                     break;
 
-                case MainWebViewActivity.THIRD_PARTY_DOMAIN_WHITELIST:
+                case BlockListHelper.THIRD_PARTY_DOMAIN_WHITELIST:
                     requestSubList.setText(R.string.third_party_domain_whitelist);
                     break;
 
                     requestSubList.setText(R.string.third_party_domain_whitelist);
                     break;
 
-                case MainWebViewActivity.THIRD_PARTY_DOMAIN_INITIAL_WHITELIST:
+                case BlockListHelper.THIRD_PARTY_DOMAIN_INITIAL_WHITELIST:
                     requestSubList.setText(R.string.third_party_domain_initial_whitelist);
                     break;
 
                     requestSubList.setText(R.string.third_party_domain_initial_whitelist);
                     break;
 
-                case MainWebViewActivity.MAIN_BLACKLIST:
+                case BlockListHelper.MAIN_BLACKLIST:
                     requestSubList.setText(R.string.main_blacklist);
                     break;
 
                     requestSubList.setText(R.string.main_blacklist);
                     break;
 
-                case MainWebViewActivity.INITIAL_BLACKLIST:
+                case BlockListHelper.INITIAL_BLACKLIST:
                     requestSubList.setText(R.string.initial_blacklist);
                     break;
 
                     requestSubList.setText(R.string.initial_blacklist);
                     break;
 
-                case MainWebViewActivity.FINAL_BLACKLIST:
+                case BlockListHelper.FINAL_BLACKLIST:
                     requestSubList.setText(R.string.final_blacklist);
                     break;
 
                     requestSubList.setText(R.string.final_blacklist);
                     break;
 
-                case MainWebViewActivity.DOMAIN_BLACKLIST:
+                case BlockListHelper.DOMAIN_BLACKLIST:
                     requestSubList.setText(R.string.domain_blacklist);
                     break;
 
                     requestSubList.setText(R.string.domain_blacklist);
                     break;
 
-                case MainWebViewActivity.DOMAIN_INITIAL_BLACKLIST:
+                case BlockListHelper.DOMAIN_INITIAL_BLACKLIST:
                     requestSubList.setText(R.string.domain_initial_blacklist);
                     break;
 
                     requestSubList.setText(R.string.domain_initial_blacklist);
                     break;
 
-                case MainWebViewActivity.DOMAIN_FINAL_BLACKLIST:
+                case BlockListHelper.DOMAIN_FINAL_BLACKLIST:
                     requestSubList.setText(R.string.domain_final_blacklist);
                     break;
 
                     requestSubList.setText(R.string.domain_final_blacklist);
                     break;
 
-                case MainWebViewActivity.DOMAIN_REGULAR_EXPRESSION_BLACKLIST:
+                case BlockListHelper.DOMAIN_REGULAR_EXPRESSION_BLACKLIST:
                     requestSubList.setText(R.string.domain_regular_expression_blacklist);
                     break;
 
                     requestSubList.setText(R.string.domain_regular_expression_blacklist);
                     break;
 
-                case MainWebViewActivity.THIRD_PARTY_BLACKLIST:
+                case BlockListHelper.THIRD_PARTY_BLACKLIST:
                     requestSubList.setText(R.string.third_party_blacklist);
                     break;
 
                     requestSubList.setText(R.string.third_party_blacklist);
                     break;
 
-                case MainWebViewActivity.THIRD_PARTY_DOMAIN_BLACKLIST:
+                case BlockListHelper.THIRD_PARTY_INITIAL_BLACKLIST:
+                    requestSubList.setText(R.string.third_party_initial_blacklist);
+                    break;
+
+                case BlockListHelper.THIRD_PARTY_DOMAIN_BLACKLIST:
                     requestSubList.setText(R.string.third_party_domain_blacklist);
                     break;
 
                     requestSubList.setText(R.string.third_party_domain_blacklist);
                     break;
 
-                case MainWebViewActivity.THIRD_PARTY_DOMAIN_INITIAL_BLACKLIST:
+                case BlockListHelper.THIRD_PARTY_DOMAIN_INITIAL_BLACKLIST:
                     requestSubList.setText(R.string.third_party_domain_initial_blacklist);
                     break;
 
                     requestSubList.setText(R.string.third_party_domain_initial_blacklist);
                     break;
 
-                case MainWebViewActivity.THIRD_PARTY_REGULAR_EXPRESSION_BLACKLIST:
+                case BlockListHelper.THIRD_PARTY_REGULAR_EXPRESSION_BLACKLIST:
                     requestSubList.setText(R.string.third_party_regular_expression_blacklist);
                     break;
 
                     requestSubList.setText(R.string.third_party_regular_expression_blacklist);
                     break;
 
-                case MainWebViewActivity.THIRD_PARTY_DOMAIN_REGULAR_EXPRESSION_BLACKLIST:
+                case BlockListHelper.THIRD_PARTY_DOMAIN_REGULAR_EXPRESSION_BLACKLIST:
                     requestSubList.setText(R.string.third_party_domain_regular_expression_blacklist);
                     break;
 
                     requestSubList.setText(R.string.third_party_domain_regular_expression_blacklist);
                     break;
 
-                case MainWebViewActivity.REGULAR_EXPRESSION_BLACKLIST:
+                case BlockListHelper.REGULAR_EXPRESSION_BLACKLIST:
                     requestSubList.setText(R.string.regular_expression_blacklist);
                     break;
             }
                     requestSubList.setText(R.string.regular_expression_blacklist);
                     break;
             }
@@ -320,4 +333,4 @@ public class ViewRequestDialog extends DialogFragment {
         // `onCreateDialog` requires the return of an alert dialog.
         return alertDialog;
     }
         // `onCreateDialog` requires the return of an alert dialog.
         return alertDialog;
     }
-}
+}
\ No newline at end of file
index 2e9773a2c4f920c1292ec874aac753f76aa7a46e..3337a96ecbf7a8f04c81bf8a56688579c445ceae 100644 (file)
@@ -1,5 +1,5 @@
 /*
 /*
- * Copyright © 2018 Soren Stoutner <soren@stoutner.com>.
+ * Copyright © 2018-2019 Soren Stoutner <soren@stoutner.com>.
  *
  * This file is part of Privacy Browser <https://www.stoutner.com/privacy-browser>.
  *
  *
  * This file is part of Privacy Browser <https://www.stoutner.com/privacy-browser>.
  *
@@ -21,8 +21,6 @@ package com.stoutner.privacybrowser.helpers;
 
 import android.content.res.AssetManager;
 
 
 import android.content.res.AssetManager;
 
-import com.stoutner.privacybrowser.activities.MainWebViewActivity;
-
 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStreamReader;
@@ -31,6 +29,46 @@ import java.util.List;
 import java.util.regex.Pattern;
 
 public class BlockListHelper {
 import java.util.regex.Pattern;
 
 public class BlockListHelper {
+    // Describe the schema of the string array in each entry of the resource requests array list.
+    public final static int REQUEST_DISPOSITION = 0;
+    public final static int REQUEST_URL = 1;
+    public final static int REQUEST_BLOCKLIST = 2;
+    public final static int REQUEST_SUBLIST = 3;
+    public final static int REQUEST_BLOCKLIST_ENTRIES = 4;
+    public final static int REQUEST_BLOCKLIST_ORIGINAL_ENTRY = 5;
+
+    // The request disposition options.
+    public final static String REQUEST_DEFAULT = "0";
+    public final static String REQUEST_ALLOWED = "1";
+    public final static String REQUEST_THIRD_PARTY = "2";
+    public final static String REQUEST_BLOCKED = "3";
+
+    // The whitelists.
+    public final static String MAIN_WHITELIST = "1";
+    public final static String FINAL_WHITELIST = "2";
+    public final static String DOMAIN_WHITELIST = "3";
+    public final static String DOMAIN_INITIAL_WHITELIST = "4";
+    public final static String DOMAIN_FINAL_WHITELIST = "5";
+    public final static String THIRD_PARTY_WHITELIST = "6";
+    public final static String THIRD_PARTY_DOMAIN_WHITELIST = "7";
+    public final static String THIRD_PARTY_DOMAIN_INITIAL_WHITELIST = "8";
+
+    // The blacklists.
+    public final static String MAIN_BLACKLIST = "9";
+    public final static String INITIAL_BLACKLIST = "10";
+    public final static String FINAL_BLACKLIST = "11";
+    public final static String DOMAIN_BLACKLIST = "12";
+    public final static String DOMAIN_INITIAL_BLACKLIST = "13";
+    public final static String DOMAIN_FINAL_BLACKLIST = "14";
+    public final static String DOMAIN_REGULAR_EXPRESSION_BLACKLIST = "15";
+    public final static String THIRD_PARTY_BLACKLIST = "16";
+    public final static String THIRD_PARTY_INITIAL_BLACKLIST = "17";
+    public final static String THIRD_PARTY_DOMAIN_BLACKLIST = "18";
+    public final static String THIRD_PARTY_DOMAIN_INITIAL_BLACKLIST = "19";
+    public final static String THIRD_PARTY_REGULAR_EXPRESSION_BLACKLIST = "20";
+    public final static String THIRD_PARTY_DOMAIN_REGULAR_EXPRESSION_BLACKLIST = "21";
+    public final static String REGULAR_EXPRESSION_BLACKLIST = "22";
+
     public ArrayList<List<String[]>> parseBlockList(AssetManager assets, String blockListName) {
         // Initialize the header list.
         List<String[]> headers = new ArrayList<>();  // 0.
     public ArrayList<List<String[]>> parseBlockList(AssetManager assets, String blockListName) {
         // Initialize the header list.
         List<String[]> headers = new ArrayList<>();  // 0.
@@ -91,7 +129,7 @@ public class BlockListHelper {
                         //Log.i("BlockLists", headers.get(1)[0] + " not added: " + originalBlockListEntry);
                 } else //noinspection StatementWithEmptyBody
                     if (blockListEntry.contains("$websocket") || blockListEntry.contains("$third-party,websocket") || blockListEntry.contains("$script,websocket")) {  // Ignore entries with `websocket`.
                         //Log.i("BlockLists", headers.get(1)[0] + " not added: " + originalBlockListEntry);
                 } else //noinspection StatementWithEmptyBody
                     if (blockListEntry.contains("$websocket") || blockListEntry.contains("$third-party,websocket") || blockListEntry.contains("$script,websocket")) {  // Ignore entries with `websocket`.
-                        // Do nothing.  Privacy Browser does not differentiate between websocket requests and other requests and these entries cause a lot of false positivies.
+                        // Do nothing.  Privacy Browser does not differentiate between websocket requests and other requests and these entries cause a lot of false positives.
 
                         //Log.i("BlockLists", headers.get(1)[0] + " not added: " + originalBlockListEntry);
                 } else if (blockListEntry.startsWith("!")) {  //  Comment entries.
 
                         //Log.i("BlockLists", headers.get(1)[0] + " not added: " + originalBlockListEntry);
                 } else if (blockListEntry.startsWith("!")) {  //  Comment entries.
@@ -1584,7 +1622,7 @@ public class BlockListHelper {
         return combinedLists;
     }
 
         return combinedLists;
     }
 
-    public boolean isBlocked(String currentDomain, String resourceUrl, boolean isThirdPartyRequest, ArrayList<List<String[]>> blockList) {
+    public String[] checkBlocklist(String currentDomain, String resourceUrl, boolean isThirdPartyRequest, ArrayList<List<String[]>> blockList) {
         // Get the blocklist name.
         String BLOCK_LIST_NAME_STRING = blockList.get(0).get(1)[0];
 
         // Get the blocklist name.
         String BLOCK_LIST_NAME_STRING = blockList.get(0).get(1)[0];
 
@@ -1596,63 +1634,42 @@ public class BlockListHelper {
 
         // Process the white lists.
         // Main white list.
 
         // Process the white lists.
         // Main white list.
-        for (String[] whiteListEntry : blockList.get(MainWebViewActivity.MAIN_WHITELIST)) {
+        for (String[] whiteListEntry : blockList.get(Integer.valueOf(MAIN_WHITELIST))) {
             switch (whiteListEntry.length) {
                 case 2:  // There is one entry.
                     if (resourceUrl.contains(whiteListEntry[0])) {
             switch (whiteListEntry.length) {
                 case 2:  // There is one entry.
                     if (resourceUrl.contains(whiteListEntry[0])) {
-                        // Store the entry in the resource request log.
-                        MainWebViewActivity.whiteListResultStringArray = new String[] {String.valueOf(MainWebViewActivity.REQUEST_ALLOWED), resourceUrl, BLOCK_LIST_NAME_STRING,
-                                String.valueOf(MainWebViewActivity.MAIN_WHITELIST), whiteListEntry[0], whiteListEntry[1]};
-
-                        // Not blocked.
-                        return false;
+                        // Return a whitelist match request allowed.
+                        return new String[] {REQUEST_ALLOWED, resourceUrl, BLOCK_LIST_NAME_STRING, MAIN_WHITELIST, whiteListEntry[0], whiteListEntry[1]};
                     }
                     break;
 
                 case 3:  // There are two entries.
                     if (resourceUrl.contains(whiteListEntry[0]) && resourceUrl.contains(whiteListEntry[1])) {
                     }
                     break;
 
                 case 3:  // There are two entries.
                     if (resourceUrl.contains(whiteListEntry[0]) && resourceUrl.contains(whiteListEntry[1])) {
-                        // Store the entry in the resource request log.
-                        MainWebViewActivity.whiteListResultStringArray = new String[] {String.valueOf(MainWebViewActivity.REQUEST_ALLOWED), resourceUrl, BLOCK_LIST_NAME_STRING,
-                                String.valueOf(MainWebViewActivity.MAIN_WHITELIST), whiteListEntry[0] + "\n" + whiteListEntry[1],
-                                whiteListEntry[2]};
-
-                        // Not blocked.
-                        return false;
+                        // Return a whitelist match request allowed.
+                        return new String[] {REQUEST_ALLOWED, resourceUrl, BLOCK_LIST_NAME_STRING, MAIN_WHITELIST, whiteListEntry[0] + "\n" + whiteListEntry[1], whiteListEntry[2]};
                     }
                     break;
 
                 case 4:  // There are three entries.
                     if (resourceUrl.contains(whiteListEntry[0]) && resourceUrl.contains(whiteListEntry[1]) && resourceUrl.contains(whiteListEntry[2])) {
                     }
                     break;
 
                 case 4:  // There are three entries.
                     if (resourceUrl.contains(whiteListEntry[0]) && resourceUrl.contains(whiteListEntry[1]) && resourceUrl.contains(whiteListEntry[2])) {
-                        // Store the entry in the resource request log.
-                        MainWebViewActivity.whiteListResultStringArray = new String[] {String.valueOf(MainWebViewActivity.REQUEST_ALLOWED), resourceUrl, BLOCK_LIST_NAME_STRING,
-                                String.valueOf(MainWebViewActivity.MAIN_WHITELIST), whiteListEntry[0] + "\n" + whiteListEntry[1] + "\n" + whiteListEntry[2], whiteListEntry[3]};
-
-                        // Not blocked.
-                        return false;
+                        // Return a whitelist match request allowed.
+                        return new String[] {REQUEST_ALLOWED, resourceUrl, BLOCK_LIST_NAME_STRING, MAIN_WHITELIST, whiteListEntry[0] + "\n" + whiteListEntry[1] + "\n" + whiteListEntry[2], whiteListEntry[3]};
                     }
                     break;
             }
         }
 
         // Final white list.
                     }
                     break;
             }
         }
 
         // Final white list.
-        for (String[] whiteListEntry : blockList.get(MainWebViewActivity.FINAL_WHITELIST)) {
+        for (String[] whiteListEntry : blockList.get(Integer.valueOf(FINAL_WHITELIST))) {
             if (whiteListEntry.length == 2) {  // There is one entry.
                 if (resourceUrl.contains(whiteListEntry[0])) {
             if (whiteListEntry.length == 2) {  // There is one entry.
                 if (resourceUrl.contains(whiteListEntry[0])) {
-                    // Store the entry in the resource request log.
-                    MainWebViewActivity.whiteListResultStringArray = new String[] {String.valueOf(MainWebViewActivity.REQUEST_ALLOWED), resourceUrl, BLOCK_LIST_NAME_STRING,
-                            String.valueOf(MainWebViewActivity.FINAL_WHITELIST), whiteListEntry[0], whiteListEntry[1]};
-
-                    // Not blocked.
-                    return false;
+                    // Return a whitelist match request allowed.
+                    return new String[] {REQUEST_ALLOWED, resourceUrl, BLOCK_LIST_NAME_STRING, FINAL_WHITELIST, whiteListEntry[0], whiteListEntry[1]};
                 }
             } else {  // There are two entries.
                 if (resourceUrl.contains(whiteListEntry[0]) && resourceUrl.contains(whiteListEntry[1])) {
                 }
             } else {  // There are two entries.
                 if (resourceUrl.contains(whiteListEntry[0]) && resourceUrl.contains(whiteListEntry[1])) {
-                    // Store the entry in the resource request log.
-                    MainWebViewActivity.whiteListResultStringArray = new String[] {String.valueOf(MainWebViewActivity.REQUEST_ALLOWED), resourceUrl, BLOCK_LIST_NAME_STRING,
-                            String.valueOf(MainWebViewActivity.FINAL_WHITELIST), whiteListEntry[0] + "\n" + whiteListEntry[1], whiteListEntry[2]};
-
-                    // Not blocked.
-                    return false;
+                    // Return a whitelist match request allowed.
+                    return new String[] {REQUEST_ALLOWED, resourceUrl, BLOCK_LIST_NAME_STRING, FINAL_WHITELIST, whiteListEntry[0] + "\n" + whiteListEntry[1], whiteListEntry[2]};
                 }
             }
         }
                 }
             }
         }
@@ -1660,119 +1677,85 @@ public class BlockListHelper {
         // Only check the domain lists if the current domain is not null (like `about:blank`).
         if (currentDomain != null) {
             // Domain white list.
         // Only check the domain lists if the current domain is not null (like `about:blank`).
         if (currentDomain != null) {
             // Domain white list.
-            for (String[] whiteListEntry : blockList.get(MainWebViewActivity.DOMAIN_WHITELIST)) {
+            for (String[] whiteListEntry : blockList.get(Integer.valueOf(DOMAIN_WHITELIST))) {
                 switch (whiteListEntry.length) {
                     case 3:  // There is one entry.
                         if (currentDomain.endsWith(whiteListEntry[0]) && resourceUrl.contains(whiteListEntry[1])) {
                 switch (whiteListEntry.length) {
                     case 3:  // There is one entry.
                         if (currentDomain.endsWith(whiteListEntry[0]) && resourceUrl.contains(whiteListEntry[1])) {
-                            // Store the entry in the resource request log.
-                            MainWebViewActivity.whiteListResultStringArray = new String[] {String.valueOf(MainWebViewActivity.REQUEST_ALLOWED), resourceUrl, BLOCK_LIST_NAME_STRING,
-                                    String.valueOf(MainWebViewActivity.DOMAIN_WHITELIST), whiteListEntry[0] + "\n" + whiteListEntry[1], whiteListEntry[2]};
-
-                            // Not blocked.
-                            return false;
+                            // Return a whitelist match request allowed.
+                            return new String[] {REQUEST_ALLOWED, resourceUrl, BLOCK_LIST_NAME_STRING, DOMAIN_WHITELIST, whiteListEntry[0] + "\n" + whiteListEntry[1], whiteListEntry[2]};
                         }
                         break;
 
                     case 4:  // There are two entries.
                         if (currentDomain.endsWith(whiteListEntry[0]) && resourceUrl.contains(whiteListEntry[1]) && resourceUrl.contains(whiteListEntry[2])) {
                         }
                         break;
 
                     case 4:  // There are two entries.
                         if (currentDomain.endsWith(whiteListEntry[0]) && resourceUrl.contains(whiteListEntry[1]) && resourceUrl.contains(whiteListEntry[2])) {
-                            // Store the entry in the resource request log.
-                            MainWebViewActivity.whiteListResultStringArray = new String[] {String.valueOf(MainWebViewActivity.REQUEST_ALLOWED), resourceUrl, BLOCK_LIST_NAME_STRING,
-                                    String.valueOf(MainWebViewActivity.DOMAIN_WHITELIST), whiteListEntry[0] + "\n" + whiteListEntry[1] + "\n" + whiteListEntry[2], whiteListEntry[3]};
-
-                            // Not blocked.
-                            return false;
+                            // Return a whitelist match request allowed.
+                            return new String[] {REQUEST_ALLOWED, resourceUrl, BLOCK_LIST_NAME_STRING, DOMAIN_WHITELIST, whiteListEntry[0] + "\n" + whiteListEntry[1] + "\n" + whiteListEntry[2],
+                                    whiteListEntry[3]};
                         }
                         break;
 
                     case 5:  // There are three entries.
                         if (currentDomain.endsWith(whiteListEntry[0]) && resourceUrl.contains(whiteListEntry[1]) && resourceUrl.contains(whiteListEntry[2]) && resourceUrl.contains(whiteListEntry[3])) {
                         }
                         break;
 
                     case 5:  // There are three entries.
                         if (currentDomain.endsWith(whiteListEntry[0]) && resourceUrl.contains(whiteListEntry[1]) && resourceUrl.contains(whiteListEntry[2]) && resourceUrl.contains(whiteListEntry[3])) {
-                            // Store the entry in the resource request log.
-                            MainWebViewActivity.whiteListResultStringArray = new String[] {String.valueOf(MainWebViewActivity.REQUEST_ALLOWED), resourceUrl, BLOCK_LIST_NAME_STRING,
-                                    String.valueOf(MainWebViewActivity.DOMAIN_WHITELIST), whiteListEntry[0] + "\n" + whiteListEntry[1] + "\n" + whiteListEntry[2] + "\n" + whiteListEntry[3],
-                                    whiteListEntry[4]};
-
-                            // Not blocked.
-                            return false;
+                            // Return a whitelist match request allowed.
+                            return new String[] {REQUEST_ALLOWED, resourceUrl, BLOCK_LIST_NAME_STRING, DOMAIN_WHITELIST, whiteListEntry[0] + "\n" + whiteListEntry[1] + "\n" + whiteListEntry[2] + "\n" +
+                                    whiteListEntry[3], whiteListEntry[4]};
                         }
                         break;
 
                     case 6:  // There are four entries.
                         if (currentDomain.endsWith(whiteListEntry[0]) && resourceUrl.contains(whiteListEntry[1]) && resourceUrl.contains(whiteListEntry[2]) && resourceUrl.contains(whiteListEntry[3]) &&
                                 resourceUrl.contains(whiteListEntry[4])) {
                         }
                         break;
 
                     case 6:  // There are four entries.
                         if (currentDomain.endsWith(whiteListEntry[0]) && resourceUrl.contains(whiteListEntry[1]) && resourceUrl.contains(whiteListEntry[2]) && resourceUrl.contains(whiteListEntry[3]) &&
                                 resourceUrl.contains(whiteListEntry[4])) {
-                            // Store the entry in the resource request log.
-                            MainWebViewActivity.whiteListResultStringArray = new String[] {String.valueOf(MainWebViewActivity.REQUEST_ALLOWED), resourceUrl, BLOCK_LIST_NAME_STRING,
-                                    String.valueOf(MainWebViewActivity.DOMAIN_WHITELIST), whiteListEntry[0] + "\n" + whiteListEntry[1] + "\n" + whiteListEntry[2] + "\n" + whiteListEntry[3] + "\n" +
-                                    whiteListEntry[4], whiteListEntry[5]};
-
-                            // Not blocked.
-                            return false;
+                            // Return a whitelist match request allowed.
+                            return new String[] {REQUEST_ALLOWED, resourceUrl, BLOCK_LIST_NAME_STRING, DOMAIN_WHITELIST, whiteListEntry[0] + "\n" + whiteListEntry[1] + "\n" + whiteListEntry[2] + "\n" +
+                                    whiteListEntry[3] + "\n" + whiteListEntry[4], whiteListEntry[5]};
                         }
                         break;
                 }
             }
 
             // Domain initial white list.
                         }
                         break;
                 }
             }
 
             // Domain initial white list.
-            for (String[] whiteListEntry : blockList.get(MainWebViewActivity.DOMAIN_INITIAL_WHITELIST)) {
+            for (String[] whiteListEntry : blockList.get(Integer.valueOf(DOMAIN_INITIAL_WHITELIST))) {
                 switch (whiteListEntry.length) {
                     case 3:  // There is one entry.
                         if (currentDomain.endsWith(whiteListEntry[0]) && resourceUrl.startsWith(whiteListEntry[1])) {
                 switch (whiteListEntry.length) {
                     case 3:  // There is one entry.
                         if (currentDomain.endsWith(whiteListEntry[0]) && resourceUrl.startsWith(whiteListEntry[1])) {
-                            // Store the entry in the resource request log.
-                            MainWebViewActivity.whiteListResultStringArray = new String[] {String.valueOf(MainWebViewActivity.REQUEST_ALLOWED), resourceUrl, BLOCK_LIST_NAME_STRING,
-                                    String.valueOf(MainWebViewActivity.DOMAIN_INITIAL_WHITELIST), whiteListEntry[0] + "\n" + whiteListEntry[1], whiteListEntry[2]};
-
-                            // Not blocked.
-                            return false;
+                            // Return a whitelist match request allowed.
+                            return new String[] {REQUEST_ALLOWED, resourceUrl, BLOCK_LIST_NAME_STRING, DOMAIN_INITIAL_WHITELIST, whiteListEntry[0] + "\n" + whiteListEntry[1], whiteListEntry[2]};
                         }
                         break;
 
                     case 4:  // There are two entries.
                         if (currentDomain.endsWith(whiteListEntry[0]) && resourceUrl.startsWith(whiteListEntry[1]) && resourceUrl.contains(whiteListEntry[2])) {
                         }
                         break;
 
                     case 4:  // There are two entries.
                         if (currentDomain.endsWith(whiteListEntry[0]) && resourceUrl.startsWith(whiteListEntry[1]) && resourceUrl.contains(whiteListEntry[2])) {
-                            // Store the entry in the resource request log.
-                            MainWebViewActivity.whiteListResultStringArray = new String[] {String.valueOf(MainWebViewActivity.REQUEST_ALLOWED), resourceUrl, BLOCK_LIST_NAME_STRING,
-                                    String.valueOf(MainWebViewActivity.DOMAIN_INITIAL_WHITELIST), whiteListEntry[0] + "\n" + whiteListEntry[1] + "\n" + whiteListEntry[2], whiteListEntry[3]};
-
-                            // Not blocked.
-                            return false;
+                            // Return a whitelist match request allowed.
+                            return new String[] {REQUEST_ALLOWED, resourceUrl, BLOCK_LIST_NAME_STRING, DOMAIN_INITIAL_WHITELIST, whiteListEntry[0] + "\n" + whiteListEntry[1] + "\n" + whiteListEntry[2],
+                                    whiteListEntry[3]};
                         }
                         break;
 
                     case 5:  // There are three entries.
                         if (currentDomain.endsWith(whiteListEntry[0]) && resourceUrl.startsWith(whiteListEntry[1]) && resourceUrl.contains(whiteListEntry[2]) && resourceUrl.startsWith(whiteListEntry[3])) {
                         }
                         break;
 
                     case 5:  // There are three entries.
                         if (currentDomain.endsWith(whiteListEntry[0]) && resourceUrl.startsWith(whiteListEntry[1]) && resourceUrl.contains(whiteListEntry[2]) && resourceUrl.startsWith(whiteListEntry[3])) {
-                            // Store the entry in the resource request log.
-                            MainWebViewActivity.whiteListResultStringArray = new String[] {String.valueOf(MainWebViewActivity.REQUEST_ALLOWED), resourceUrl, BLOCK_LIST_NAME_STRING,
-                                    String.valueOf(MainWebViewActivity.DOMAIN_INITIAL_WHITELIST), whiteListEntry[0] + "\n" + whiteListEntry[1] + "\n" + whiteListEntry[2] + "\n" + whiteListEntry[3],
-                                    whiteListEntry[4]};
-
-                            // Not blocked.
-                            return false;
+                            // Return a whitelist match request allowed.
+                            return new String[] {REQUEST_ALLOWED, resourceUrl, BLOCK_LIST_NAME_STRING, DOMAIN_INITIAL_WHITELIST, whiteListEntry[0] + "\n" + whiteListEntry[1] + "\n" + whiteListEntry[2] + "\n" +
+                                    whiteListEntry[3], whiteListEntry[4]};
                         }
                         break;
                 }
             }
 
             // Domain final white list.
                         }
                         break;
                 }
             }
 
             // Domain final white list.
-            for (String[] whiteListEntry : blockList.get(MainWebViewActivity.DOMAIN_FINAL_WHITELIST)) {
+            for (String[] whiteListEntry : blockList.get(Integer.valueOf(DOMAIN_FINAL_WHITELIST))) {
                 switch (whiteListEntry.length) {
                     case 3:  // There is one entry;
                         if (currentDomain.endsWith(whiteListEntry[0]) && resourceUrl.endsWith(whiteListEntry[1])) {
                 switch (whiteListEntry.length) {
                     case 3:  // There is one entry;
                         if (currentDomain.endsWith(whiteListEntry[0]) && resourceUrl.endsWith(whiteListEntry[1])) {
-                            // Store the entry in the resource request log.
-                            MainWebViewActivity.whiteListResultStringArray = new String[] {String.valueOf(MainWebViewActivity.REQUEST_ALLOWED), resourceUrl, BLOCK_LIST_NAME_STRING,
-                                    String.valueOf(MainWebViewActivity.DOMAIN_FINAL_WHITELIST), whiteListEntry[0] + "\n" + whiteListEntry[1], whiteListEntry[2]};
-
-                            // Not blocked.
-                            return false;
+                            // Return a whitelist match request allowed.
+                            return new String[] {REQUEST_ALLOWED, resourceUrl, BLOCK_LIST_NAME_STRING, DOMAIN_FINAL_WHITELIST, whiteListEntry[0] + "\n" + whiteListEntry[1], whiteListEntry[2]};
                         }
                         break;
 
                     case 4:  // There are two entries;
                         if (currentDomain.endsWith(whiteListEntry[0]) && resourceUrl.contains(whiteListEntry[1]) && resourceUrl.endsWith(whiteListEntry[2])) {
                         }
                         break;
 
                     case 4:  // There are two entries;
                         if (currentDomain.endsWith(whiteListEntry[0]) && resourceUrl.contains(whiteListEntry[1]) && resourceUrl.endsWith(whiteListEntry[2])) {
-                            // Store the entry in the resource request log.
-                            MainWebViewActivity.whiteListResultStringArray = new String[] {String.valueOf(MainWebViewActivity.REQUEST_ALLOWED), resourceUrl, BLOCK_LIST_NAME_STRING,
-                                    String.valueOf(MainWebViewActivity.DOMAIN_FINAL_WHITELIST), whiteListEntry[0] + "\n" + whiteListEntry[1] + "\n" + whiteListEntry[2], whiteListEntry[3]};
-
-
-                            // Not blocked.
-                            return false;
+                            // Return a whitelist match request allowed.
+                            return new String[] {REQUEST_ALLOWED, resourceUrl, BLOCK_LIST_NAME_STRING, DOMAIN_FINAL_WHITELIST, whiteListEntry[0] + "\n" + whiteListEntry[1] + "\n" + whiteListEntry[2],
+                                    whiteListEntry[3]};
                         }
                         break;
                 }
                         }
                         break;
                 }
@@ -1782,109 +1765,77 @@ public class BlockListHelper {
         // Only check the third-party white lists if this is a third-party request.
         if (isThirdPartyRequest) {
             // Third-party white list.
         // Only check the third-party white lists if this is a third-party request.
         if (isThirdPartyRequest) {
             // Third-party white list.
-            for (String[] whiteListEntry : blockList.get(MainWebViewActivity.THIRD_PARTY_WHITELIST)) {
+            for (String[] whiteListEntry : blockList.get(Integer.valueOf(THIRD_PARTY_WHITELIST))) {
                 switch (whiteListEntry.length) {
                     case 2:  // There is one entry
                         if (resourceUrl.contains(whiteListEntry[0])) {
                 switch (whiteListEntry.length) {
                     case 2:  // There is one entry
                         if (resourceUrl.contains(whiteListEntry[0])) {
-                            // Store the entry in the resource request log.
-                            MainWebViewActivity.whiteListResultStringArray = new String[] {String.valueOf(MainWebViewActivity.REQUEST_ALLOWED), resourceUrl, BLOCK_LIST_NAME_STRING,
-                                    String.valueOf(MainWebViewActivity.THIRD_PARTY_WHITELIST), whiteListEntry[0], whiteListEntry[1]};
-
-                            // Not blocked.
-                            return false;
+                            // Return a whitelist match request allowed.
+                            return new String[] {REQUEST_ALLOWED, resourceUrl, BLOCK_LIST_NAME_STRING, THIRD_PARTY_WHITELIST, whiteListEntry[0], whiteListEntry[1]};
                         }
                         break;
 
                     case 3:  // There are two entries.
                         if (resourceUrl.contains(whiteListEntry[0]) && resourceUrl.contains(whiteListEntry[1])) {
                         }
                         break;
 
                     case 3:  // There are two entries.
                         if (resourceUrl.contains(whiteListEntry[0]) && resourceUrl.contains(whiteListEntry[1])) {
-                            // Store the entry in the resource request log.
-                            MainWebViewActivity.whiteListResultStringArray = new String[] {String.valueOf(MainWebViewActivity.REQUEST_ALLOWED), resourceUrl, BLOCK_LIST_NAME_STRING,
-                                    String.valueOf(MainWebViewActivity.THIRD_PARTY_WHITELIST), whiteListEntry[0] + "\n" + whiteListEntry[1], whiteListEntry[2]};
-
-                            // Not blocked.
-                            return false;
+                            // Return a whitelist match request allowed.
+                            return new String[] {REQUEST_ALLOWED, resourceUrl, BLOCK_LIST_NAME_STRING, THIRD_PARTY_WHITELIST, whiteListEntry[0] + "\n" + whiteListEntry[1], whiteListEntry[2]};
                         }
                         break;
 
                     case 4:  // There are three entries.
                         if (resourceUrl.contains(whiteListEntry[0]) && resourceUrl.contains(whiteListEntry[1]) && resourceUrl.contains(whiteListEntry[2])) {
                         }
                         break;
 
                     case 4:  // There are three entries.
                         if (resourceUrl.contains(whiteListEntry[0]) && resourceUrl.contains(whiteListEntry[1]) && resourceUrl.contains(whiteListEntry[2])) {
-                            // Store the entry in the resource request log.
-                            MainWebViewActivity.whiteListResultStringArray = new String[] {String.valueOf(MainWebViewActivity.REQUEST_ALLOWED), resourceUrl, BLOCK_LIST_NAME_STRING,
-                                    String.valueOf(MainWebViewActivity.THIRD_PARTY_WHITELIST), whiteListEntry[0] + "\n" + whiteListEntry[1] + "\n" + whiteListEntry[2], whiteListEntry[3]};
-
-                            // Not blocked.
-                            return false;
+                            // Return a whitelist match request allowed.
+                            return new String[] {REQUEST_ALLOWED, resourceUrl, BLOCK_LIST_NAME_STRING, THIRD_PARTY_WHITELIST, whiteListEntry[0] + "\n" + whiteListEntry[1] + "\n" + whiteListEntry[2],
+                                    whiteListEntry[3]};
                         }
                         break;
 
                     case 5:  // There are four entries.
                         if (resourceUrl.contains(whiteListEntry[0]) && resourceUrl.contains(whiteListEntry[1]) && resourceUrl.contains(whiteListEntry[2]) && resourceUrl.contains(whiteListEntry[3])) {
                         }
                         break;
 
                     case 5:  // There are four entries.
                         if (resourceUrl.contains(whiteListEntry[0]) && resourceUrl.contains(whiteListEntry[1]) && resourceUrl.contains(whiteListEntry[2]) && resourceUrl.contains(whiteListEntry[3])) {
-                            // Store the entry in the resource request log.
-                            MainWebViewActivity.whiteListResultStringArray = new String[] {String.valueOf(MainWebViewActivity.REQUEST_ALLOWED), resourceUrl, BLOCK_LIST_NAME_STRING,
-                                    String.valueOf(MainWebViewActivity.THIRD_PARTY_WHITELIST), whiteListEntry[0] + "\n" + whiteListEntry[1] + "\n" + whiteListEntry[2] + "\n" + whiteListEntry[3],
-                                    whiteListEntry[4]};
-                            // Not blocked.
-                            return false;
+                            // Return a whitelist match request allowed.
+                            return new String[] {REQUEST_ALLOWED, resourceUrl, BLOCK_LIST_NAME_STRING, THIRD_PARTY_WHITELIST, whiteListEntry[0] + "\n" + whiteListEntry[1] + "\n" + whiteListEntry[2] + "\n" +
+                                    whiteListEntry[3], whiteListEntry[4]};
                         }
                         break;
 
                     case 6:  // There are five entries.
                         if (resourceUrl.contains(whiteListEntry[0]) && resourceUrl.contains(whiteListEntry[1]) && resourceUrl.contains(whiteListEntry[2]) && resourceUrl.contains(whiteListEntry[3]) &&
                                 resourceUrl.contains(whiteListEntry[4])) {
                         }
                         break;
 
                     case 6:  // There are five entries.
                         if (resourceUrl.contains(whiteListEntry[0]) && resourceUrl.contains(whiteListEntry[1]) && resourceUrl.contains(whiteListEntry[2]) && resourceUrl.contains(whiteListEntry[3]) &&
                                 resourceUrl.contains(whiteListEntry[4])) {
-                            // Store the entry in the resource request log.
-                            MainWebViewActivity.whiteListResultStringArray = new String[] {String.valueOf(MainWebViewActivity.REQUEST_ALLOWED), resourceUrl, BLOCK_LIST_NAME_STRING,
-                                    String.valueOf(MainWebViewActivity.THIRD_PARTY_WHITELIST), whiteListEntry[0] + "\n" + whiteListEntry[1] + "\n" + whiteListEntry[2] + "\n" + whiteListEntry[3] + "\n" +
-                                    whiteListEntry[4], whiteListEntry[5]};
-
-                            // Not blocked.
-                            return false;
+                            // Return a whitelist match request allowed.
+                            return new String[] {REQUEST_ALLOWED, resourceUrl, BLOCK_LIST_NAME_STRING, THIRD_PARTY_WHITELIST, whiteListEntry[0] + "\n" + whiteListEntry[1] + "\n" + whiteListEntry[2] + "\n" +
+                                    whiteListEntry[3] + "\n" + whiteListEntry[4], whiteListEntry[5]};
                         }
                         break;
                 }
             }
 
             // Third-party domain white list.
                         }
                         break;
                 }
             }
 
             // Third-party domain white list.
-            for (String[] whiteListEntry : blockList.get(MainWebViewActivity.THIRD_PARTY_DOMAIN_WHITELIST)) {
+            for (String[] whiteListEntry : blockList.get(Integer.valueOf(THIRD_PARTY_DOMAIN_WHITELIST))) {
                 if (whiteListEntry.length == 3) {  // There is one entry.
                     if (currentDomain.endsWith(whiteListEntry[0]) && resourceUrl.contains(whiteListEntry[1])) {
                 if (whiteListEntry.length == 3) {  // There is one entry.
                     if (currentDomain.endsWith(whiteListEntry[0]) && resourceUrl.contains(whiteListEntry[1])) {
-                        // Store the entry in the resource request log.
-                        MainWebViewActivity.whiteListResultStringArray = new String[] {String.valueOf(MainWebViewActivity.REQUEST_ALLOWED), resourceUrl, BLOCK_LIST_NAME_STRING,
-                                String.valueOf(MainWebViewActivity.THIRD_PARTY_DOMAIN_WHITELIST), whiteListEntry[0] + "\n" + whiteListEntry[1], whiteListEntry[2]};
-
-                        // Not blocked.
-                        return false;
+                        // Return a whitelist match request allowed.
+                        return new String[] {REQUEST_ALLOWED, resourceUrl, BLOCK_LIST_NAME_STRING, THIRD_PARTY_DOMAIN_WHITELIST, whiteListEntry[0] + "\n" + whiteListEntry[1], whiteListEntry[2]};
                     }
                 } else {  // There are two entries.
                     if (currentDomain.endsWith(whiteListEntry[0]) && resourceUrl.contains(whiteListEntry[1]) && resourceUrl.contains(whiteListEntry[2])) {
                     }
                 } else {  // There are two entries.
                     if (currentDomain.endsWith(whiteListEntry[0]) && resourceUrl.contains(whiteListEntry[1]) && resourceUrl.contains(whiteListEntry[2])) {
-                        // Store the entry in the resource request log.
-                        MainWebViewActivity.whiteListResultStringArray = new String[] {String.valueOf(MainWebViewActivity.REQUEST_ALLOWED), resourceUrl, BLOCK_LIST_NAME_STRING,
-                                String.valueOf(MainWebViewActivity.THIRD_PARTY_DOMAIN_WHITELIST), whiteListEntry[0] + "\n" + whiteListEntry[1] + "\n" + whiteListEntry[2], whiteListEntry[3]};
-
-                        // Not blocked.
-                        return false;
+                        // Return a whitelist match request allowed.
+                        return new String[] {REQUEST_ALLOWED, resourceUrl, BLOCK_LIST_NAME_STRING, THIRD_PARTY_DOMAIN_WHITELIST, whiteListEntry[0] + "\n" + whiteListEntry[1] + "\n" + whiteListEntry[2],
+                                whiteListEntry[3]};
                     }
                 }
             }
 
             // Third-party domain initial white list.
                     }
                 }
             }
 
             // Third-party domain initial white list.
-            for (String[] whiteListEntry : blockList.get(MainWebViewActivity.THIRD_PARTY_DOMAIN_INITIAL_WHITELIST)) {
+            for (String[] whiteListEntry : blockList.get(Integer.valueOf(THIRD_PARTY_DOMAIN_INITIAL_WHITELIST))) {
                 if (whiteListEntry.length == 3) {  // There is one entry.
                     if (currentDomain.endsWith(whiteListEntry[0]) && resourceUrl.startsWith(whiteListEntry[1])) {
                 if (whiteListEntry.length == 3) {  // There is one entry.
                     if (currentDomain.endsWith(whiteListEntry[0]) && resourceUrl.startsWith(whiteListEntry[1])) {
-                        // Store the entry in the resource request log.
-                        MainWebViewActivity.whiteListResultStringArray = new String[] {String.valueOf(MainWebViewActivity.REQUEST_ALLOWED), resourceUrl, BLOCK_LIST_NAME_STRING,
-                                String.valueOf(MainWebViewActivity.THIRD_PARTY_DOMAIN_INITIAL_WHITELIST), whiteListEntry[0] + "\n" + whiteListEntry[1], whiteListEntry[2]};
-
-                        // Not blocked.
-                        return false;
+                        // Return a whitelist match request allowed.
+                        return new String[] {REQUEST_ALLOWED, resourceUrl, BLOCK_LIST_NAME_STRING, THIRD_PARTY_DOMAIN_INITIAL_WHITELIST, whiteListEntry[0] + "\n" + whiteListEntry[1], whiteListEntry[2]};
                     }
                 } else {  // There are two entries.
                     if (currentDomain.endsWith(whiteListEntry[0]) && resourceUrl.startsWith(whiteListEntry[1]) && resourceUrl.contains(whiteListEntry[2])) {
                     }
                 } else {  // There are two entries.
                     if (currentDomain.endsWith(whiteListEntry[0]) && resourceUrl.startsWith(whiteListEntry[1]) && resourceUrl.contains(whiteListEntry[2])) {
-                        // Store the entry in the resource request log.
-                        MainWebViewActivity.whiteListResultStringArray = new String[] {String.valueOf(MainWebViewActivity.REQUEST_ALLOWED), resourceUrl, BLOCK_LIST_NAME_STRING,
-                                String.valueOf(MainWebViewActivity.THIRD_PARTY_DOMAIN_WHITELIST), whiteListEntry[0] + "\n" + whiteListEntry[1] + "\n" + whiteListEntry[2], whiteListEntry[3]};
-
-                        // Not blocked.
-                        return false;
+                        // Return a whitelist match request allowed.
+                        return new String[] {REQUEST_ALLOWED, resourceUrl, BLOCK_LIST_NAME_STRING, THIRD_PARTY_DOMAIN_WHITELIST, whiteListEntry[0] + "\n" + whiteListEntry[1] + "\n" + whiteListEntry[2],
+                                whiteListEntry[3]};
                     }
                 }
             }
                     }
                 }
             }
@@ -1892,123 +1843,84 @@ public class BlockListHelper {
 
         // Process the black lists.
         // Main black list.
 
         // Process the black lists.
         // Main black list.
-        for (String[] blackListEntry : blockList.get(MainWebViewActivity.MAIN_BLACKLIST)) {
+        for (String[] blackListEntry : blockList.get(Integer.valueOf(MAIN_BLACKLIST))) {
             switch (blackListEntry.length) {
                 case 2:  // There is one entry.
                     if (resourceUrl.contains(blackListEntry[0])) {
             switch (blackListEntry.length) {
                 case 2:  // There is one entry.
                     if (resourceUrl.contains(blackListEntry[0])) {
-                        // Store the entry in the resource request log.
-                        MainWebViewActivity.resourceRequests.add(new String[] {String.valueOf(MainWebViewActivity.REQUEST_BLOCKED), resourceUrl, BLOCK_LIST_NAME_STRING,
-                                String.valueOf(MainWebViewActivity.MAIN_BLACKLIST), blackListEntry[0], blackListEntry[1]});
-
-                        // Blocked.
-                        return true;
+                        // Return a blacklist match request blocked.
+                        return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, MAIN_BLACKLIST, blackListEntry[0], blackListEntry[1]};
                     }
                     break;
 
                 case 3:  // There are two entries.
                     if (resourceUrl.contains(blackListEntry[0]) && resourceUrl.contains(blackListEntry[1])) {
                     }
                     break;
 
                 case 3:  // There are two entries.
                     if (resourceUrl.contains(blackListEntry[0]) && resourceUrl.contains(blackListEntry[1])) {
-                        // Store the entry in the resource request log.
-                        MainWebViewActivity.resourceRequests.add(new String[] {String.valueOf(MainWebViewActivity.REQUEST_BLOCKED), resourceUrl, BLOCK_LIST_NAME_STRING,
-                                String.valueOf(MainWebViewActivity.MAIN_BLACKLIST), blackListEntry[0] + "\n" + blackListEntry[1], blackListEntry[2]});
-
-                        // Blocked.
-                        return true;
+                        // Return a blacklist match request blocked.
+                        return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, MAIN_BLACKLIST, blackListEntry[0] + "\n" + blackListEntry[1], blackListEntry[2]};
                     }
                     break;
 
                 case 4:  // There are three entries.
                     if (resourceUrl.contains(blackListEntry[0]) && resourceUrl.contains(blackListEntry[1]) && resourceUrl.contains(blackListEntry[2])) {
                     }
                     break;
 
                 case 4:  // There are three entries.
                     if (resourceUrl.contains(blackListEntry[0]) && resourceUrl.contains(blackListEntry[1]) && resourceUrl.contains(blackListEntry[2])) {
-                        // Store the entry in the resource request log.
-                        MainWebViewActivity.resourceRequests.add(new String[] {String.valueOf(MainWebViewActivity.REQUEST_BLOCKED), resourceUrl, BLOCK_LIST_NAME_STRING,
-                                String.valueOf(MainWebViewActivity.MAIN_BLACKLIST), blackListEntry[0] + "\n" + blackListEntry[1] + "\n" + blackListEntry[2], blackListEntry[3]});
-
-                        // Blocked.
-                        return true;
+                        // Return a blacklist match request blocked.
+                        return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, MAIN_BLACKLIST, blackListEntry[0] + "\n" + blackListEntry[1] + "\n" + blackListEntry[2], blackListEntry[3]};
                     }
                     break;
 
                 case 5:  // There are four entries.
                     if (resourceUrl.contains(blackListEntry[0]) && resourceUrl.contains(blackListEntry[1]) && resourceUrl.contains(blackListEntry[2]) && resourceUrl.contains(blackListEntry[3])) {
                     }
                     break;
 
                 case 5:  // There are four entries.
                     if (resourceUrl.contains(blackListEntry[0]) && resourceUrl.contains(blackListEntry[1]) && resourceUrl.contains(blackListEntry[2]) && resourceUrl.contains(blackListEntry[3])) {
-                        // Store the entry in the resource request log.
-                        MainWebViewActivity.resourceRequests.add(new String[] {String.valueOf(MainWebViewActivity.REQUEST_BLOCKED), resourceUrl, BLOCK_LIST_NAME_STRING,
-                                String.valueOf(MainWebViewActivity.MAIN_BLACKLIST), blackListEntry[0] + "\n" + blackListEntry[1] + "\n" + blackListEntry[2] + "\n" + blackListEntry[3], blackListEntry[4]});
-
-                        // Blocked.
-                        return true;
+                        // Return a blacklist match request blocked.
+                        return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, MAIN_BLACKLIST, blackListEntry[0] + "\n" + blackListEntry[1] + "\n" + blackListEntry[2] + "\n" +
+                                blackListEntry[3], blackListEntry[4]};
                     }
                     break;
 
                 case 6:  // There are five entries.
                     if (resourceUrl.contains(blackListEntry[0]) && resourceUrl.contains(blackListEntry[1]) && resourceUrl.contains(blackListEntry[2]) && resourceUrl.contains(blackListEntry[3]) &&
                             resourceUrl.contains(blackListEntry[4])) {
                     }
                     break;
 
                 case 6:  // There are five entries.
                     if (resourceUrl.contains(blackListEntry[0]) && resourceUrl.contains(blackListEntry[1]) && resourceUrl.contains(blackListEntry[2]) && resourceUrl.contains(blackListEntry[3]) &&
                             resourceUrl.contains(blackListEntry[4])) {
-                        // Store the entry in the resource request log.
-                        MainWebViewActivity.resourceRequests.add(new String[] {String.valueOf(MainWebViewActivity.REQUEST_BLOCKED), resourceUrl, BLOCK_LIST_NAME_STRING,
-                                String.valueOf(MainWebViewActivity.MAIN_BLACKLIST), blackListEntry[0] + "\n" + blackListEntry[1] + "\n" + blackListEntry[2] + "\n" + blackListEntry[3] + "\n" +
-                                blackListEntry[4], blackListEntry[5]});
-
-                        // Blocked.
-                        return true;
+                        // Return a blacklist match request blocked.
+                        return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, MAIN_BLACKLIST, blackListEntry[0] + "\n" + blackListEntry[1] + "\n" + blackListEntry[2] + "\n" +
+                                blackListEntry[3] + "\n" + blackListEntry[4], blackListEntry[5]};
                     }
                     break;
             }
         }
 
         // Initial black list.
                     }
                     break;
             }
         }
 
         // Initial black list.
-        for (String[] blackListEntry : blockList.get(MainWebViewActivity.INITIAL_BLACKLIST)) {
+        for (String[] blackListEntry : blockList.get(Integer.valueOf(INITIAL_BLACKLIST))) {
             if (blackListEntry.length == 2) {  // There is one entry.
                 if (resourceUrl.startsWith(blackListEntry[0])) {
             if (blackListEntry.length == 2) {  // There is one entry.
                 if (resourceUrl.startsWith(blackListEntry[0])) {
-                    // Store the entry in the resource request log.
-                    MainWebViewActivity.resourceRequests.add(new String[] {String.valueOf(MainWebViewActivity.REQUEST_BLOCKED), resourceUrl, BLOCK_LIST_NAME_STRING,
-                            String.valueOf(MainWebViewActivity.INITIAL_BLACKLIST), blackListEntry[0], blackListEntry[1]});
-
-                    // Blocked.
-                    return true;
+                    // Return a blacklist match request blocked.
+                    return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, INITIAL_BLACKLIST, blackListEntry[0], blackListEntry[1]};
                 }
             } else {  // There are two entries
                 if (resourceUrl.startsWith(blackListEntry[0]) && resourceUrl.contains(blackListEntry[1])) {
                 }
             } else {  // There are two entries
                 if (resourceUrl.startsWith(blackListEntry[0]) && resourceUrl.contains(blackListEntry[1])) {
-                    // Store the entry in the resource request log.
-                    MainWebViewActivity.resourceRequests.add(new String[] {String.valueOf(MainWebViewActivity.REQUEST_BLOCKED), resourceUrl, BLOCK_LIST_NAME_STRING,
-                            String.valueOf(MainWebViewActivity.INITIAL_BLACKLIST), blackListEntry[0] + "\n" + blackListEntry[1], blackListEntry[2]});
-
-                    // Blocked.
-                    return true;
+                    // Return a blacklist match request blocked.
+                    return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, INITIAL_BLACKLIST, blackListEntry[0] + "\n" + blackListEntry[1], blackListEntry[2]};
                 }
             }
         }
 
         // Final black list.
                 }
             }
         }
 
         // Final black list.
-        for (String[] blackListEntry : blockList.get(MainWebViewActivity.FINAL_BLACKLIST)) {
+        for (String[] blackListEntry : blockList.get(Integer.valueOf(FINAL_BLACKLIST))) {
             switch (blackListEntry.length) {
                 case 2:  // There is one entry.
                     if (resourceUrl.endsWith(blackListEntry[0])) {
             switch (blackListEntry.length) {
                 case 2:  // There is one entry.
                     if (resourceUrl.endsWith(blackListEntry[0])) {
-                        // Store the entry in the resource request log.
-                        MainWebViewActivity.resourceRequests.add(new String[] {String.valueOf(MainWebViewActivity.REQUEST_BLOCKED), resourceUrl, BLOCK_LIST_NAME_STRING,
-                                String.valueOf(MainWebViewActivity.FINAL_BLACKLIST), blackListEntry[0], blackListEntry[1]});
-
-                        // Blocked.
-                        return true;
+                        // Return a blacklist match request blocked.
+                        return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, FINAL_BLACKLIST, blackListEntry[0], blackListEntry[1]};
                     }
                     break;
 
                 case 3:  // There are two entries.
                     if (resourceUrl.contains(blackListEntry[0]) && resourceUrl.endsWith(blackListEntry[1])) {
                     }
                     break;
 
                 case 3:  // There are two entries.
                     if (resourceUrl.contains(blackListEntry[0]) && resourceUrl.endsWith(blackListEntry[1])) {
-                        // Store the entry in the resource request log.
-                        MainWebViewActivity.resourceRequests.add(new String[] {String.valueOf(MainWebViewActivity.REQUEST_BLOCKED), resourceUrl, BLOCK_LIST_NAME_STRING,
-                                String.valueOf(MainWebViewActivity.FINAL_BLACKLIST), blackListEntry[0] + "\n" + blackListEntry[1], blackListEntry[2]});
-
-                        // Blocked.
-                        return true;
+                        // Return a blacklist match request blocked.
+                        return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, FINAL_BLACKLIST, blackListEntry[0] + "\n" + blackListEntry[1], blackListEntry[2]};
                     }
                     break;
 
                 case 4:  // There are three entries.
                     if (resourceUrl.contains(blackListEntry[0]) && resourceUrl.contains(blackListEntry[1]) && resourceUrl.endsWith(blackListEntry[2])) {
                     }
                     break;
 
                 case 4:  // There are three entries.
                     if (resourceUrl.contains(blackListEntry[0]) && resourceUrl.contains(blackListEntry[1]) && resourceUrl.endsWith(blackListEntry[2])) {
-                        // Store the entry in the resource request log.
-                        MainWebViewActivity.resourceRequests.add(new String[] {String.valueOf(MainWebViewActivity.REQUEST_BLOCKED), resourceUrl, BLOCK_LIST_NAME_STRING,
-                                String.valueOf(MainWebViewActivity.FINAL_BLACKLIST), blackListEntry[0] + "\n" + blackListEntry[1] + "\n" + blackListEntry[2], blackListEntry[3]});
-
-                        // Blocked.
-                        return true;
+                        // Return a blacklist match request blocked.
+                        return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, FINAL_BLACKLIST, blackListEntry[0] + "\n" + blackListEntry[1] + "\n" + blackListEntry[2], blackListEntry[3]};
                     }
                     break;
             }
                     }
                     break;
             }
@@ -2017,93 +1929,67 @@ public class BlockListHelper {
         // Only check the domain lists if the current domain is not null (like `about:blank`).
         if (currentDomain != null) {
             // Domain black list.
         // Only check the domain lists if the current domain is not null (like `about:blank`).
         if (currentDomain != null) {
             // Domain black list.
-            for (String[] blackListEntry : blockList.get(MainWebViewActivity.DOMAIN_BLACKLIST)) {
+            for (String[] blackListEntry : blockList.get(Integer.valueOf(DOMAIN_BLACKLIST))) {
                 switch (blackListEntry.length) {
                     case 3:  // There is one entry.
                         if (currentDomain.endsWith(blackListEntry[0]) && resourceUrl.contains(blackListEntry[1])) {
                 switch (blackListEntry.length) {
                     case 3:  // There is one entry.
                         if (currentDomain.endsWith(blackListEntry[0]) && resourceUrl.contains(blackListEntry[1])) {
-                            // Store the entry in the resource request log.
-                            MainWebViewActivity.resourceRequests.add(new String[] {String.valueOf(MainWebViewActivity.REQUEST_BLOCKED), resourceUrl, BLOCK_LIST_NAME_STRING,
-                                    String.valueOf(MainWebViewActivity.DOMAIN_BLACKLIST), blackListEntry[0] + "\n" + blackListEntry[1], blackListEntry[2]});
-
-                            // Blocked.
-                            return true;
+                            // Return a blacklist match request blocked.
+                            return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, DOMAIN_BLACKLIST, blackListEntry[0] + "\n" + blackListEntry[1], blackListEntry[2]};
                         }
                         break;
 
                     case 4:  // There are two entries.
                         if (currentDomain.endsWith(blackListEntry[0]) && resourceUrl.contains(blackListEntry[1]) && resourceUrl.contains(blackListEntry[2])) {
                         }
                         break;
 
                     case 4:  // There are two entries.
                         if (currentDomain.endsWith(blackListEntry[0]) && resourceUrl.contains(blackListEntry[1]) && resourceUrl.contains(blackListEntry[2])) {
-                            // Store the entry in the resource request log.
-                            MainWebViewActivity.resourceRequests.add(new String[] {String.valueOf(MainWebViewActivity.REQUEST_BLOCKED), resourceUrl, BLOCK_LIST_NAME_STRING,
-                                    String.valueOf(MainWebViewActivity.DOMAIN_BLACKLIST), blackListEntry[0] + "\n" + blackListEntry[1] + "\n" + blackListEntry[2], blackListEntry[3]});
-
-                            // Blocked.
-                            return true;
+                            // Return a blacklist match request blocked.
+                            return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, DOMAIN_BLACKLIST, blackListEntry[0] + "\n" + blackListEntry[1] + "\n" + blackListEntry[2],
+                                    blackListEntry[3]};
                         }
                         break;
 
                     case 5:  // There are three entries.
                         if (currentDomain.endsWith(blackListEntry[0]) && resourceUrl.contains(blackListEntry[1]) && resourceUrl.contains(blackListEntry[2]) && resourceUrl.contains(blackListEntry[3])) {
                         }
                         break;
 
                     case 5:  // There are three entries.
                         if (currentDomain.endsWith(blackListEntry[0]) && resourceUrl.contains(blackListEntry[1]) && resourceUrl.contains(blackListEntry[2]) && resourceUrl.contains(blackListEntry[3])) {
-                            // Store the entry in the resource request log.
-                            MainWebViewActivity.resourceRequests.add(new String[] {String.valueOf(MainWebViewActivity.REQUEST_BLOCKED), resourceUrl, BLOCK_LIST_NAME_STRING,
-                                    String.valueOf(MainWebViewActivity.DOMAIN_BLACKLIST), blackListEntry[0] + "\n" + blackListEntry[1] + "\n" + blackListEntry[2] + "\n" + blackListEntry[3],
-                                    blackListEntry[4]});
-
-                            // Blocked.
-                            return true;
+                            // Return a blacklist match request blocked.
+                            return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, DOMAIN_BLACKLIST, blackListEntry[0] + "\n" + blackListEntry[1] + "\n" + blackListEntry[2] + "\n" +
+                                    blackListEntry[3], blackListEntry[4]};
                         }
                         break;
                 }
             }
 
             // Domain initial black list.
                         }
                         break;
                 }
             }
 
             // Domain initial black list.
-            for (String[] blackListEntry : blockList.get(MainWebViewActivity.DOMAIN_INITIAL_BLACKLIST)) {
+            for (String[] blackListEntry : blockList.get(Integer.valueOf(DOMAIN_INITIAL_BLACKLIST))) {
                 // Store the entry in the resource request log.
                 if (currentDomain.endsWith(blackListEntry[0]) && resourceUrl.startsWith(blackListEntry[1])) {
                 // Store the entry in the resource request log.
                 if (currentDomain.endsWith(blackListEntry[0]) && resourceUrl.startsWith(blackListEntry[1])) {
-                    MainWebViewActivity.resourceRequests.add(new String[] {String.valueOf(MainWebViewActivity.REQUEST_BLOCKED), resourceUrl, BLOCK_LIST_NAME_STRING,
-                            String.valueOf(MainWebViewActivity.DOMAIN_INITIAL_BLACKLIST), blackListEntry[0] + "\n" + blackListEntry[1],
-                            blackListEntry[2]});
-
-                    // Blocked.
-                    return true;
+                    // Return a blacklist match request blocked.
+                    return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, DOMAIN_INITIAL_BLACKLIST, blackListEntry[0] + "\n" + blackListEntry[1], blackListEntry[2]};
                 }
             }
 
             // Domain final black list.
                 }
             }
 
             // Domain final black list.
-            for (String[] blackListEntry : blockList.get(MainWebViewActivity.DOMAIN_FINAL_BLACKLIST)) {
+            for (String[] blackListEntry : blockList.get(Integer.valueOf(DOMAIN_FINAL_BLACKLIST))) {
                 switch (blackListEntry.length) {
                     case 3:  // There is one entry.
                         if (currentDomain.endsWith(blackListEntry[0]) && resourceUrl.endsWith(blackListEntry[1])) {
                 switch (blackListEntry.length) {
                     case 3:  // There is one entry.
                         if (currentDomain.endsWith(blackListEntry[0]) && resourceUrl.endsWith(blackListEntry[1])) {
-                            // Store the entry in the resource request log.
-                            MainWebViewActivity.resourceRequests.add(new String[] {String.valueOf(MainWebViewActivity.REQUEST_BLOCKED), resourceUrl, BLOCK_LIST_NAME_STRING,
-                                    String.valueOf(MainWebViewActivity.DOMAIN_FINAL_BLACKLIST), blackListEntry[0] + "\n" + blackListEntry[1], blackListEntry[2]});
-
-                            // Blocked.
-                            return true;
+                            // Return a blacklist match request blocked.
+                            return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, DOMAIN_FINAL_BLACKLIST, blackListEntry[0] + "\n" + blackListEntry[1], blackListEntry[2]};
                         }
                         break;
 
                     case 4:  // There are two entries.
                         if (currentDomain.endsWith(blackListEntry[0]) && resourceUrl.contains(blackListEntry[1]) && resourceUrl.endsWith(blackListEntry[2])) {
                         }
                         break;
 
                     case 4:  // There are two entries.
                         if (currentDomain.endsWith(blackListEntry[0]) && resourceUrl.contains(blackListEntry[1]) && resourceUrl.endsWith(blackListEntry[2])) {
-                            // Store the entry in the resource request log.
-                            MainWebViewActivity.resourceRequests.add(new String[] {String.valueOf(MainWebViewActivity.REQUEST_BLOCKED), resourceUrl, BLOCK_LIST_NAME_STRING,
-                                    String.valueOf(MainWebViewActivity.DOMAIN_FINAL_BLACKLIST), blackListEntry[0] + "\n" + blackListEntry[1] + "\n" + blackListEntry[2], blackListEntry[3]});
-
-                            // Blocked.
-                            return true;
+                            // Return a blacklist match request blocked.
+                            return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, DOMAIN_FINAL_BLACKLIST, blackListEntry[0] + "\n" + blackListEntry[1] + "\n" + blackListEntry[2],
+                                    blackListEntry[3]};
                         }
                         break;
                 }
             }
 
             // Domain regular expression black list.
                         }
                         break;
                 }
             }
 
             // Domain regular expression black list.
-            for (String[] blackListEntry : blockList.get(MainWebViewActivity.DOMAIN_REGULAR_EXPRESSION_BLACKLIST)) {
+            for (String[] blackListEntry : blockList.get(Integer.valueOf(DOMAIN_REGULAR_EXPRESSION_BLACKLIST))) {
                 if (currentDomain.endsWith(blackListEntry[0]) && Pattern.matches(blackListEntry[1], resourceUrl)) {
                 if (currentDomain.endsWith(blackListEntry[0]) && Pattern.matches(blackListEntry[1], resourceUrl)) {
-                    // Store the entry in the resource request log.
-                    MainWebViewActivity.resourceRequests.add(new String[] {String.valueOf(MainWebViewActivity.REQUEST_BLOCKED), resourceUrl, BLOCK_LIST_NAME_STRING,
-                            String.valueOf(MainWebViewActivity.DOMAIN_REGULAR_EXPRESSION_BLACKLIST), blackListEntry[0] + "\n" + blackListEntry[1], blackListEntry[2]});
-
-                    // Blocked.
-                    return true;
+                    // Return a blacklist match request blocked.
+                    return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, DOMAIN_REGULAR_EXPRESSION_BLACKLIST, blackListEntry[0] + "\n" + blackListEntry[1], blackListEntry[2]};
                 }
             }
         }
                 }
             }
         }
@@ -2111,177 +1997,125 @@ public class BlockListHelper {
         // Only check the third-party black lists if this is a third-party request.
         if (isThirdPartyRequest) {
             // Third-party black list.
         // Only check the third-party black lists if this is a third-party request.
         if (isThirdPartyRequest) {
             // Third-party black list.
-            for (String[] blackListEntry : blockList.get(MainWebViewActivity.THIRD_PARTY_BLACKLIST)) {
+            for (String[] blackListEntry : blockList.get(Integer.valueOf(THIRD_PARTY_BLACKLIST))) {
                 switch (blackListEntry.length) {
                     case 2:  // There is one entry.
                         if (resourceUrl.contains(blackListEntry[0])) {
                 switch (blackListEntry.length) {
                     case 2:  // There is one entry.
                         if (resourceUrl.contains(blackListEntry[0])) {
-                            // Store the entry in the resource request log.
-                            MainWebViewActivity.resourceRequests.add(new String[] {String.valueOf(MainWebViewActivity.REQUEST_BLOCKED), resourceUrl, BLOCK_LIST_NAME_STRING,
-                                    String.valueOf(MainWebViewActivity.THIRD_PARTY_BLACKLIST), blackListEntry[0], blackListEntry[1]});
-
-                            // Blocked.
-                            return true;
+                            // Return a blacklist match request blocked.
+                            return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, THIRD_PARTY_BLACKLIST, blackListEntry[0], blackListEntry[1]};
                         }
                         break;
 
                     case 3:  // There are two entries.
                         if (resourceUrl.contains(blackListEntry[0]) && resourceUrl.contains(blackListEntry[1])) {
                         }
                         break;
 
                     case 3:  // There are two entries.
                         if (resourceUrl.contains(blackListEntry[0]) && resourceUrl.contains(blackListEntry[1])) {
-                            // Store the entry in the resource request log.
-                            MainWebViewActivity.resourceRequests.add(new String[] {String.valueOf(MainWebViewActivity.REQUEST_BLOCKED), resourceUrl, BLOCK_LIST_NAME_STRING,
-                                    String.valueOf(MainWebViewActivity.THIRD_PARTY_BLACKLIST), blackListEntry[0] + "\n" + blackListEntry[1], blackListEntry[2]});
-
-                            // Blocked.
-                            return true;
+                            // Return a blacklist match request blocked.
+                            return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, THIRD_PARTY_BLACKLIST, blackListEntry[0] + "\n" + blackListEntry[1], blackListEntry[2]};
                         }
                         break;
 
                     case 4:  // There are three entries.
                         if (resourceUrl.contains(blackListEntry[0]) && resourceUrl.contains(blackListEntry[1]) && resourceUrl.contains(blackListEntry[2])) {
                         }
                         break;
 
                     case 4:  // There are three entries.
                         if (resourceUrl.contains(blackListEntry[0]) && resourceUrl.contains(blackListEntry[1]) && resourceUrl.contains(blackListEntry[2])) {
-                            // Store the entry in the resource request log.
-                            MainWebViewActivity.resourceRequests.add(new String[] {String.valueOf(MainWebViewActivity.REQUEST_BLOCKED), resourceUrl, BLOCK_LIST_NAME_STRING,
-                                    String.valueOf(MainWebViewActivity.THIRD_PARTY_BLACKLIST), blackListEntry[0] + "\n" + blackListEntry[1] + "\n" + blackListEntry[2], blackListEntry[3]});
-
-                            // Blocked.
-                            return true;
+                            // Return a blacklist match request blocked.
+                            return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, THIRD_PARTY_BLACKLIST, blackListEntry[0] + "\n" + blackListEntry[1] + "\n" + blackListEntry[2],
+                                    blackListEntry[3]};
                         }
                         break;
 
                     case 5:  // There are four entries.
                         if (resourceUrl.contains(blackListEntry[0]) && resourceUrl.contains(blackListEntry[1]) && resourceUrl.contains(blackListEntry[2]) && resourceUrl.contains(blackListEntry[3])) {
                         }
                         break;
 
                     case 5:  // There are four entries.
                         if (resourceUrl.contains(blackListEntry[0]) && resourceUrl.contains(blackListEntry[1]) && resourceUrl.contains(blackListEntry[2]) && resourceUrl.contains(blackListEntry[3])) {
-                            // Store the entry in the resource request log.
-                            MainWebViewActivity.resourceRequests.add(new String[] {String.valueOf(MainWebViewActivity.REQUEST_BLOCKED), resourceUrl, BLOCK_LIST_NAME_STRING,
-                                    String.valueOf(MainWebViewActivity.THIRD_PARTY_BLACKLIST), blackListEntry[0] + "\n" + blackListEntry[1] + "\n" + blackListEntry[2] + "\n" + blackListEntry[3],
-                                    blackListEntry[4]});
-
-                            // Blocked.
-                            return true;
+                            // Return a blacklist match request blocked.
+                            return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, THIRD_PARTY_BLACKLIST, blackListEntry[0] + "\n" + blackListEntry[1] + "\n" + blackListEntry[2] + "\n" +
+                                    blackListEntry[3], blackListEntry[4]};
                         }
                         break;
                 }
             }
 
             // Third-party initial black list.
                         }
                         break;
                 }
             }
 
             // Third-party initial black list.
-            for (String[] blackListEntry : blockList.get(MainWebViewActivity.THIRD_PARTY_INITIAL_BLACKLIST)) {
+            for (String[] blackListEntry : blockList.get(Integer.valueOf(THIRD_PARTY_INITIAL_BLACKLIST))) {
                 if (blackListEntry.length == 2) {  // There is one entry.
                     if (resourceUrl.startsWith(blackListEntry[0])) {
                 if (blackListEntry.length == 2) {  // There is one entry.
                     if (resourceUrl.startsWith(blackListEntry[0])) {
-                        // Store the entry in the resource request log.
-                        MainWebViewActivity.resourceRequests.add(new String[] {String.valueOf(MainWebViewActivity.REQUEST_BLOCKED), resourceUrl, BLOCK_LIST_NAME_STRING,
-                                String.valueOf(MainWebViewActivity.THIRD_PARTY_INITIAL_BLACKLIST), blackListEntry[0], blackListEntry[1]});
-
-                        // Blocked.
-                        return true;
+                        // Return a blacklist match request blocked.
+                        return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, THIRD_PARTY_INITIAL_BLACKLIST, blackListEntry[0], blackListEntry[1]};
                     }
                 } else {  // There are two entries.
                     if (resourceUrl.startsWith(blackListEntry[0]) && resourceUrl.contains(blackListEntry[1])) {
                     }
                 } else {  // There are two entries.
                     if (resourceUrl.startsWith(blackListEntry[0]) && resourceUrl.contains(blackListEntry[1])) {
-                        // Store the entry in the resource request log.
-                        MainWebViewActivity.resourceRequests.add(new String[] {String.valueOf(MainWebViewActivity.REQUEST_BLOCKED), resourceUrl, BLOCK_LIST_NAME_STRING,
-                                String.valueOf(MainWebViewActivity.THIRD_PARTY_INITIAL_BLACKLIST), blackListEntry[0] + "\n" + blackListEntry[1], blackListEntry[2]});
-
-                        // Blocked.
-                        return true;
+                        // Return a blacklist match request blocked.
+                        return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, THIRD_PARTY_INITIAL_BLACKLIST, blackListEntry[0] + "\n" + blackListEntry[1], blackListEntry[2]};
                     }
                 }
             }
 
             // Third-party domain black list.
                     }
                 }
             }
 
             // Third-party domain black list.
-            for (String[] blackListEntry : blockList.get(MainWebViewActivity.THIRD_PARTY_DOMAIN_BLACKLIST)) {
+            for (String[] blackListEntry : blockList.get(Integer.valueOf(THIRD_PARTY_DOMAIN_BLACKLIST))) {
                 if (blackListEntry.length == 3) {  // There is one entry.
                     if (currentDomain.endsWith(blackListEntry[0]) && resourceUrl.contains(blackListEntry[1])) {
                 if (blackListEntry.length == 3) {  // There is one entry.
                     if (currentDomain.endsWith(blackListEntry[0]) && resourceUrl.contains(blackListEntry[1])) {
-                        // Store the entry in the resource request log.
-                        MainWebViewActivity.resourceRequests.add(new String[] {String.valueOf(MainWebViewActivity.REQUEST_BLOCKED), resourceUrl, BLOCK_LIST_NAME_STRING,
-                                String.valueOf(MainWebViewActivity.THIRD_PARTY_DOMAIN_BLACKLIST), blackListEntry[0] + "\n" + blackListEntry[1], blackListEntry[2]});
-
-                        // Blocked.
-                        return true;
+                        // Return a blacklist match request blocked.
+                        return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, THIRD_PARTY_DOMAIN_BLACKLIST, blackListEntry[0] + "\n" + blackListEntry[1], blackListEntry[2]};
                     }
                 } else { // There are two entries.
                     if (currentDomain.endsWith(blackListEntry[0]) && resourceUrl.contains(blackListEntry[1]) && resourceUrl.contains(blackListEntry[2])) {
                     }
                 } else { // There are two entries.
                     if (currentDomain.endsWith(blackListEntry[0]) && resourceUrl.contains(blackListEntry[1]) && resourceUrl.contains(blackListEntry[2])) {
-                        // Store the entry in the resource request log.
-                        MainWebViewActivity.resourceRequests.add(new String[] {String.valueOf(MainWebViewActivity.REQUEST_BLOCKED), resourceUrl, BLOCK_LIST_NAME_STRING,
-                                String.valueOf(MainWebViewActivity.THIRD_PARTY_DOMAIN_BLACKLIST), blackListEntry[0] + "\n" + blackListEntry[1] + "\n" + blackListEntry[2], blackListEntry[3]});
-
-                        // Blocked.
-                        return true;
+                        // Return a blacklist match request blocked.
+                        return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, THIRD_PARTY_DOMAIN_BLACKLIST, blackListEntry[0] + "\n" + blackListEntry[1] + "\n" + blackListEntry[2],
+                                blackListEntry[3]};
                     }
                 }
             }
 
             // Third-party domain initial black list.
                     }
                 }
             }
 
             // Third-party domain initial black list.
-            for (String[] blackListEntry : blockList.get(MainWebViewActivity.THIRD_PARTY_DOMAIN_INITIAL_BLACKLIST)) {
+            for (String[] blackListEntry : blockList.get(Integer.valueOf(THIRD_PARTY_DOMAIN_INITIAL_BLACKLIST))) {
                 switch (blackListEntry.length) {
                     case 3:  // There is one entry.
                         if (currentDomain.endsWith(blackListEntry[0]) && resourceUrl.startsWith(blackListEntry[1])) {
                 switch (blackListEntry.length) {
                     case 3:  // There is one entry.
                         if (currentDomain.endsWith(blackListEntry[0]) && resourceUrl.startsWith(blackListEntry[1])) {
-                            // Store the entry in the resource request log.
-                            MainWebViewActivity.resourceRequests.add(new String[] {String.valueOf(MainWebViewActivity.REQUEST_BLOCKED), resourceUrl, BLOCK_LIST_NAME_STRING,
-                                    String.valueOf(MainWebViewActivity.THIRD_PARTY_DOMAIN_INITIAL_BLACKLIST), blackListEntry[0] + "\n" + blackListEntry[1], blackListEntry[2]});
-                            // Blocked.
-                            return true;
+                            // Return a blacklist match request blocked.
+                            return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, THIRD_PARTY_DOMAIN_INITIAL_BLACKLIST, blackListEntry[0] + "\n" + blackListEntry[1], blackListEntry[2]};
                         }
                         break;
 
                     case 4:  // There are two entries.
                         if (currentDomain.endsWith(blackListEntry[0]) && resourceUrl.startsWith(blackListEntry[1]) && resourceUrl.contains(blackListEntry[2])) {
                         }
                         break;
 
                     case 4:  // There are two entries.
                         if (currentDomain.endsWith(blackListEntry[0]) && resourceUrl.startsWith(blackListEntry[1]) && resourceUrl.contains(blackListEntry[2])) {
-                            // Store the entry in the resource request log.
-                            MainWebViewActivity.resourceRequests.add(new String[] {String.valueOf(MainWebViewActivity.REQUEST_BLOCKED), resourceUrl, BLOCK_LIST_NAME_STRING,
-                                    String.valueOf(MainWebViewActivity.THIRD_PARTY_DOMAIN_INITIAL_BLACKLIST), blackListEntry[0] + "\n" + blackListEntry[1] + "\n" + blackListEntry[2], blackListEntry[3]});
-
-                            // Blocked.
-                            return true;
+                            // Return a blacklist match request blocked.
+                            return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, THIRD_PARTY_DOMAIN_INITIAL_BLACKLIST, blackListEntry[0] + "\n" + blackListEntry[1] + "\n" +
+                                    blackListEntry[2], blackListEntry[3]};
                         }
                         break;
 
                     case 5:  // There are three entries.
                         if (currentDomain.endsWith(blackListEntry[0]) && resourceUrl.startsWith(blackListEntry[1]) && resourceUrl.contains(blackListEntry[2]) && resourceUrl.contains(blackListEntry[3])) {
                         }
                         break;
 
                     case 5:  // There are three entries.
                         if (currentDomain.endsWith(blackListEntry[0]) && resourceUrl.startsWith(blackListEntry[1]) && resourceUrl.contains(blackListEntry[2]) && resourceUrl.contains(blackListEntry[3])) {
-                            // Store the entry in the resource request log.
-                            MainWebViewActivity.resourceRequests.add(new String[] {String.valueOf(MainWebViewActivity.REQUEST_BLOCKED), resourceUrl, BLOCK_LIST_NAME_STRING,
-                                    String.valueOf(MainWebViewActivity.THIRD_PARTY_DOMAIN_INITIAL_BLACKLIST), blackListEntry[0] + "\n" + blackListEntry[1] + "\n" + blackListEntry[2] + "\n" + blackListEntry[3],
-                                    blackListEntry[4]});
-
-                            // Blocked.
-                            return true;
+                            // Return a blacklist match request blocked.
+                            return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, THIRD_PARTY_DOMAIN_INITIAL_BLACKLIST, blackListEntry[0] + "\n" + blackListEntry[1] + "\n" +
+                                    blackListEntry[2] + "\n" + blackListEntry[3], blackListEntry[4]};
                         }
                         break;
                 }
             }
 
             // Third-party regular expression black list.
                         }
                         break;
                 }
             }
 
             // Third-party regular expression black list.
-            for (String[] blackListEntry : blockList.get(MainWebViewActivity.THIRD_PARTY_REGULAR_EXPRESSION_BLACKLIST)) {
+            for (String[] blackListEntry : blockList.get(Integer.valueOf(THIRD_PARTY_REGULAR_EXPRESSION_BLACKLIST))) {
                 if (Pattern.matches(blackListEntry[0], resourceUrl)) {
                 if (Pattern.matches(blackListEntry[0], resourceUrl)) {
-                    // Store the entry in the resource request log.
-                    MainWebViewActivity.resourceRequests.add(new String[] {String.valueOf(MainWebViewActivity.REQUEST_BLOCKED), resourceUrl, BLOCK_LIST_NAME_STRING,
-                            String.valueOf(MainWebViewActivity.THIRD_PARTY_REGULAR_EXPRESSION_BLACKLIST), blackListEntry[0], blackListEntry[1]});
-
-                    // Blocked.
-                    return true;
+                    // Return a blacklist match request blocked.
+                    return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, THIRD_PARTY_REGULAR_EXPRESSION_BLACKLIST, blackListEntry[0], blackListEntry[1]};
                 }
             }
 
             // Third-party domain regular expression black list.
                 }
             }
 
             // Third-party domain regular expression black list.
-            for (String[] blackListEntry : blockList.get(MainWebViewActivity.THIRD_PARTY_DOMAIN_REGULAR_EXPRESSION_BLACKLIST)) {
+            for (String[] blackListEntry : blockList.get(Integer.valueOf(THIRD_PARTY_DOMAIN_REGULAR_EXPRESSION_BLACKLIST))) {
                 if (currentDomain.endsWith(blackListEntry[0]) && Pattern.matches(blackListEntry[1], resourceUrl)) {
                 if (currentDomain.endsWith(blackListEntry[0]) && Pattern.matches(blackListEntry[1], resourceUrl)) {
-                    // Store the entry in the resource request log.
-                    MainWebViewActivity.resourceRequests.add(new String[] {String.valueOf(MainWebViewActivity.REQUEST_BLOCKED), resourceUrl, BLOCK_LIST_NAME_STRING,
-                            String.valueOf(MainWebViewActivity.THIRD_PARTY_DOMAIN_REGULAR_EXPRESSION_BLACKLIST), blackListEntry[0] + "\n" + blackListEntry[1], blackListEntry[2]});
-
-                    // Blocked.
-                    return true;
+                    // Return a blacklist match request blocked.
+                    return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, THIRD_PARTY_DOMAIN_REGULAR_EXPRESSION_BLACKLIST, blackListEntry[0] + "\n" + blackListEntry[1], blackListEntry[2]};
                 }
             }
         }
 
         // Regular expression black list.
                 }
             }
         }
 
         // Regular expression black list.
-        for (String[] blackListEntry : blockList.get(MainWebViewActivity.REGULAR_EXPRESSION_BLACKLIST)) {
+        for (String[] blackListEntry : blockList.get(Integer.valueOf(REGULAR_EXPRESSION_BLACKLIST))) {
             if (Pattern.matches(blackListEntry[0], resourceUrl)) {
             if (Pattern.matches(blackListEntry[0], resourceUrl)) {
-                // Store the entry in the resource request log.
-                MainWebViewActivity.resourceRequests.add(new String[] {String.valueOf(MainWebViewActivity.REQUEST_BLOCKED), resourceUrl, BLOCK_LIST_NAME_STRING,
-                        String.valueOf(MainWebViewActivity.REGULAR_EXPRESSION_BLACKLIST), blackListEntry[0], blackListEntry[1]});
-
-                // blocked.
-                return true;
+                // Return a blacklist match request blocked.
+                return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, REGULAR_EXPRESSION_BLACKLIST, blackListEntry[0], blackListEntry[1]};
             }
         }
 
             }
         }
 
-        // Not blocked.
-        return false;
+        // Return a no match request default.
+        return new String[] {REQUEST_DEFAULT};
     }
 }
\ No newline at end of file
     }
 }
\ No newline at end of file
index 5044b27df449d0b498d681e477211042bd142932..c4f54de9ee2488dc985a6ecdb0ba9fa2b599ccb1 100644 (file)
@@ -28,8 +28,19 @@ import androidx.core.view.NestedScrollingChild2;
 import androidx.core.view.NestedScrollingChildHelper;
 import androidx.core.view.ViewCompat;
 
 import androidx.core.view.NestedScrollingChildHelper;
 import androidx.core.view.ViewCompat;
 
+import java.util.ArrayList;
+
 // NestedScrollWebView extends WebView to handle nested scrolls (scrolling the app bar off the screen).
 public class NestedScrollWebView extends WebView implements NestedScrollingChild2 {
 // NestedScrollWebView extends WebView to handle nested scrolls (scrolling the app bar off the screen).
 public class NestedScrollWebView extends WebView implements NestedScrollingChild2 {
+    // These constants identify the blocklists.
+    public final static int BLOCKED_REQUESTS = 0;
+    public final static int EASY_LIST_BLOCKED_REQUESTS = 1;
+    public final static int EASY_PRIVACY_BLOCKED_REQUESTS = 2;
+    public final static int FANBOYS_ANNOYANCE_LIST_BLOCKED_REQUESTS = 3;
+    public final static int FANBOYS_SOCIAL_BLOCKING_LIST_BLOCKED_REQUESTS = 4;
+    public final static int ULTRA_PRIVACY_BLOCKED_REQUESTS = 5;
+    public final static int THIRD_PARTY_BLOCKED_REQUESTS = 6;
+
     // The nested scrolling child helper is used throughout the class.
     private NestedScrollingChildHelper nestedScrollingChildHelper;
 
     // The nested scrolling child helper is used throughout the class.
     private NestedScrollingChildHelper nestedScrollingChildHelper;
 
@@ -40,6 +51,16 @@ public class NestedScrollWebView extends WebView implements NestedScrollingChild
     private boolean domainSettingsApplied;
     private int domainSettingsDatabaseId;
 
     private boolean domainSettingsApplied;
     private int domainSettingsDatabaseId;
 
+    // Track the resource requests.
+    private ArrayList<String[]> resourceRequests = new ArrayList<>();
+    private int blockedRequests;
+    private int easyListBlockedRequests;
+    private int easyPrivacyBlockedRequests;
+    private int fanboysAnnoyanceListBlockedRequests;
+    private int fanboysSocialBlockingListBlockedRequests;
+    private int ultraPrivacyBlockedRequests;
+    private int thirdPartyBlockedRequests;
+
     // Basic constructor.
     public NestedScrollWebView(Context context) {
         // Roll up to the next constructor.
     // Basic constructor.
     public NestedScrollWebView(Context context) {
         // Roll up to the next constructor.
@@ -84,6 +105,138 @@ public class NestedScrollWebView extends WebView implements NestedScrollingChild
         return domainSettingsDatabaseId;
     }
 
         return domainSettingsDatabaseId;
     }
 
+    public void addResourceRequest(String[] resourceRequest) {
+        // Add the resource request to the list.
+        resourceRequests.add(resourceRequest);
+    }
+
+    public ArrayList<String[]> getResourceRequests() {
+        // Return the list of resource requests.
+        return resourceRequests;
+    }
+
+    public void clearResourceRequests() {
+        // Clear the resource requests.
+        resourceRequests.clear();
+    }
+
+    public void resetRequestsCount(int list) {
+        // Run the command on the indicated list.
+        switch (list) {
+            case BLOCKED_REQUESTS:
+                // Reset the blocked requests count.
+                blockedRequests = 0;
+                break;
+
+            case EASY_LIST_BLOCKED_REQUESTS:
+                // Reset the EasyList blocked requests count.
+                easyListBlockedRequests = 0;
+                break;
+
+            case EASY_PRIVACY_BLOCKED_REQUESTS:
+                // Reset the EasyPrivacy blocked requests count.
+                easyPrivacyBlockedRequests = 0;
+                break;
+
+            case FANBOYS_ANNOYANCE_LIST_BLOCKED_REQUESTS:
+                // Reset the Fanboy's Annoyance List blocked requests count.
+                fanboysAnnoyanceListBlockedRequests = 0;
+                break;
+
+            case FANBOYS_SOCIAL_BLOCKING_LIST_BLOCKED_REQUESTS:
+                // Reset the Fanboy's Social Blocking List blocked requests count.
+                fanboysSocialBlockingListBlockedRequests = 0;
+                break;
+
+            case ULTRA_PRIVACY_BLOCKED_REQUESTS:
+                // Reset the UltraPrivacy blocked requests count.
+                ultraPrivacyBlockedRequests = 0;
+                break;
+
+            case THIRD_PARTY_BLOCKED_REQUESTS:
+                // Reset the Third Party blocked requests count.
+                thirdPartyBlockedRequests = 0;
+                break;
+        }
+    }
+
+    public void incrementRequestsCount(int list) {
+        // Run the command on the indicated list.
+        switch (list) {
+            case BLOCKED_REQUESTS:
+                // Increment the blocked requests count.
+                blockedRequests++;
+                break;
+
+            case EASY_LIST_BLOCKED_REQUESTS:
+                // Increment the EasyList blocked requests count.
+                easyListBlockedRequests++;
+                break;
+
+            case EASY_PRIVACY_BLOCKED_REQUESTS:
+                // Increment the EasyPrivacy blocked requests count.
+                easyPrivacyBlockedRequests++;
+                break;
+
+            case FANBOYS_ANNOYANCE_LIST_BLOCKED_REQUESTS:
+                // Increment the Fanboy's Annoyance List blocked requests count.
+                fanboysAnnoyanceListBlockedRequests++;
+                break;
+
+            case FANBOYS_SOCIAL_BLOCKING_LIST_BLOCKED_REQUESTS:
+                // Increment the Fanboy's Social Blocking List blocked requests count.
+                fanboysSocialBlockingListBlockedRequests++;
+                break;
+
+            case ULTRA_PRIVACY_BLOCKED_REQUESTS:
+                // Increment the UltraPrivacy blocked requests count.
+                ultraPrivacyBlockedRequests++;
+                break;
+
+            case THIRD_PARTY_BLOCKED_REQUESTS:
+                // Increment the Third Party blocked requests count.
+                thirdPartyBlockedRequests++;
+                break;
+        }
+    }
+
+    public int getRequestsCount(int list) {
+        // Run the command on the indicated list.
+        switch (list) {
+            case BLOCKED_REQUESTS:
+                // Return the blocked requests count.
+                return blockedRequests;
+
+            case EASY_LIST_BLOCKED_REQUESTS:
+                // Return the EasyList blocked requests count.
+                return easyListBlockedRequests;
+
+            case EASY_PRIVACY_BLOCKED_REQUESTS:
+                // Return the EasyPrivacy blocked requests count.
+                return easyPrivacyBlockedRequests;
+
+            case FANBOYS_ANNOYANCE_LIST_BLOCKED_REQUESTS:
+                // Return the Fanboy's Annoyance List blocked requests count.
+                return fanboysAnnoyanceListBlockedRequests;
+
+            case FANBOYS_SOCIAL_BLOCKING_LIST_BLOCKED_REQUESTS:
+                // Return the Fanboy's Social Blocking List blocked requests count.
+                return fanboysSocialBlockingListBlockedRequests;
+
+            case ULTRA_PRIVACY_BLOCKED_REQUESTS:
+                // Return the UltraPrivacy blocked requests count.
+                return ultraPrivacyBlockedRequests;
+
+            case THIRD_PARTY_BLOCKED_REQUESTS:
+                // Return the Third Party blocked requests count.
+                return thirdPartyBlockedRequests;
+
+            default:
+                // Return 0.  This should never end up being called.
+                return 0;
+        }
+    }
+
     @Override
     public boolean onTouchEvent(MotionEvent motionEvent) {
         // Initialize a tracker to return if this motion event is handled.
     @Override
     public boolean onTouchEvent(MotionEvent motionEvent) {
         // Initialize a tracker to return if this motion event is handled.