app/src/main/java/com/stoutner/privacybrowser/views/NestedScrollWebView.java

   1 /*
   2  * Copyright © 2019 Soren Stoutner <soren@stoutner.com>.
   3  *
   4  * This file is part of Privacy Browser <https://www.stoutner.com/privacy-browser>.
   5  *
   6  * Privacy Browser is free software: you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation, either version 3 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * Privacy Browser is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with Privacy Browser.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 package com.stoutner.privacybrowser.views;
  21
  22 import android.content.Context;
  23 import android.util.AttributeSet;
  24 import android.view.MotionEvent;
  25 import android.webkit.WebView;
  26
  27 import androidx.core.view.NestedScrollingChild2;
  28 import androidx.core.view.NestedScrollingChildHelper;
  29 import androidx.core.view.ViewCompat;
  30
  31 import java.util.ArrayList;
  32 import java.util.Date;
  33
  34 // NestedScrollWebView extends WebView to handle nested scrolls (scrolling the app bar off the screen).
  35 public class NestedScrollWebView extends WebView implements NestedScrollingChild2 {
  36     // These constants identify the blocklists.
  37     public final static int BLOCKED_REQUESTS = 0;
  38     public final static int EASY_LIST_BLOCKED_REQUESTS = 1;
  39     public final static int EASY_PRIVACY_BLOCKED_REQUESTS = 2;
  40     public final static int FANBOYS_ANNOYANCE_LIST_BLOCKED_REQUESTS = 3;
  41     public final static int FANBOYS_SOCIAL_BLOCKING_LIST_BLOCKED_REQUESTS = 4;
  42     public final static int ULTRA_PRIVACY_BLOCKED_REQUESTS = 5;
  43     public final static int THIRD_PARTY_BLOCKED_REQUESTS = 6;
  44
  45     // Keep a copy of the WebView fragment ID.
  46     private long webViewFragmentId;
  47
  48     // Track if domain settings are applied to this nested scroll WebView and, if so, the database ID.
  49     private boolean domainSettingsApplied;
  50     private int domainSettingsDatabaseId;
  51
  52     // Track the resource requests.
  53     private ArrayList<String[]> resourceRequests = new ArrayList<>();
  54     private int blockedRequests;
  55     private int easyListBlockedRequests;
  56     private int easyPrivacyBlockedRequests;
  57     private int fanboysAnnoyanceListBlockedRequests;
  58     private int fanboysSocialBlockingListBlockedRequests;
  59     private int ultraPrivacyBlockedRequests;
  60     private int thirdPartyBlockedRequests;
  61
  62     // The pinned SSL certificate variables.
  63     private boolean hasPinnedSslCertificate;
  64     private String pinnedSslIssuedToCName;
  65     private String pinnedSslIssuedToOName;
  66     private String pinnedSslIssuedToUName;
  67     private String pinnedSslIssuedByCName;
  68     private String pinnedSslIssuedByOName;
  69     private String pinnedSslIssuedByUName;
  70     private Date pinnedSslStartDate;
  71     private Date pinnedSslEndDate;
  72
  73     // The current IP addresses variables.
  74     private boolean hasCurrentIpAddresses;
  75     private String currentIpAddresses;
  76
  77     // The pinned IP addresses variables.
  78     private boolean hasPinnedIpAddresses;
  79     private String pinnedIpAddresses;
  80
  81     // The ignore pinned domain information tracker.  This is set when a user proceeds past a pinned mismatch dialog to prevent the dialog from showing again until after the domain changes.
  82     private boolean ignorePinnedDomainInformation;
  83
  84     // The nested scrolling child helper is used throughout the class.
  85     private NestedScrollingChildHelper nestedScrollingChildHelper;
  86
  87     // The previous Y position needs to be tracked between motion events.
  88     private int previousYPosition;
  89
  90
  91
  92     // The basic constructor.
  93     public NestedScrollWebView(Context context) {
  94         // Roll up to the next constructor.
  95         this(context, null);
  96     }
  97
  98     // The intermediate constructor.
  99     public NestedScrollWebView(Context context, AttributeSet attributeSet) {
 100         // Roll up to the next constructor.
 101         this(context, attributeSet, android.R.attr.webViewStyle);
 102     }
 103
 104     // The full constructor.
 105     public NestedScrollWebView(Context context, AttributeSet attributeSet, int defaultStyle) {
 106         // Run the default commands.
 107         super(context, attributeSet, defaultStyle);
 108
 109         // Initialize the nested scrolling child helper.
 110         nestedScrollingChildHelper = new NestedScrollingChildHelper(this);
 111
 112         // Enable nested scrolling by default.
 113         nestedScrollingChildHelper.setNestedScrollingEnabled(true);
 114     }
 115
 116
 117
 118     // WebView Fragment ID.
 119     public void setWebViewFragmentId(long webViewFragmentId) {
 120         // Store the WebView fragment ID.
 121         this.webViewFragmentId = webViewFragmentId;
 122     }
 123
 124     public long getWebViewFragmentId() {
 125         // Return the WebView fragment ID.
 126         return webViewFragmentId;
 127     }
 128
 129
 130     // Domain settings.
 131     public void setDomainSettingsApplied(boolean applied) {
 132         // Store the domain settings applied status.
 133         domainSettingsApplied = applied;
 134     }
 135
 136     public boolean getDomainSettingsApplied() {
 137         // Return the domain settings applied status.
 138         return domainSettingsApplied;
 139     }
 140
 141
 142     // Domain settings database ID.
 143     public void setDomainSettingsDatabaseId(int databaseId) {
 144         // Store the domain settings database ID.
 145         domainSettingsDatabaseId = databaseId;
 146     }
 147
 148     public int getDomainSettingsDatabaseId() {
 149         // Return the domain settings database ID.
 150         return domainSettingsDatabaseId;
 151     }
 152
 153
 154     // Resource requests.
 155     public void addResourceRequest(String[] resourceRequest) {
 156         // Add the resource request to the list.
 157         resourceRequests.add(resourceRequest);
 158     }
 159
 160     public ArrayList<String[]> getResourceRequests() {
 161         // Return the list of resource requests.
 162         return resourceRequests;
 163     }
 164
 165     public void clearResourceRequests() {
 166         // Clear the resource requests.
 167         resourceRequests.clear();
 168     }
 169
 170
 171     // Resource request counters.
 172     public void resetRequestsCount(int list) {
 173         // Run the command on the indicated list.
 174         switch (list) {
 175             case BLOCKED_REQUESTS:
 176                 // Reset the blocked requests count.
 177                 blockedRequests = 0;
 178                 break;
 179
 180             case EASY_LIST_BLOCKED_REQUESTS:
 181                 // Reset the EasyList blocked requests count.
 182                 easyListBlockedRequests = 0;
 183                 break;
 184
 185             case EASY_PRIVACY_BLOCKED_REQUESTS:
 186                 // Reset the EasyPrivacy blocked requests count.
 187                 easyPrivacyBlockedRequests = 0;
 188                 break;
 189
 190             case FANBOYS_ANNOYANCE_LIST_BLOCKED_REQUESTS:
 191                 // Reset the Fanboy's Annoyance List blocked requests count.
 192                 fanboysAnnoyanceListBlockedRequests = 0;
 193                 break;
 194
 195             case FANBOYS_SOCIAL_BLOCKING_LIST_BLOCKED_REQUESTS:
 196                 // Reset the Fanboy's Social Blocking List blocked requests count.
 197                 fanboysSocialBlockingListBlockedRequests = 0;
 198                 break;
 199
 200             case ULTRA_PRIVACY_BLOCKED_REQUESTS:
 201                 // Reset the UltraPrivacy blocked requests count.
 202                 ultraPrivacyBlockedRequests = 0;
 203                 break;
 204
 205             case THIRD_PARTY_BLOCKED_REQUESTS:
 206                 // Reset the Third Party blocked requests count.
 207                 thirdPartyBlockedRequests = 0;
 208                 break;
 209         }
 210     }
 211
 212     public void incrementRequestsCount(int list) {
 213         // Run the command on the indicated list.
 214         switch (list) {
 215             case BLOCKED_REQUESTS:
 216                 // Increment the blocked requests count.
 217                 blockedRequests++;
 218                 break;
 219
 220             case EASY_LIST_BLOCKED_REQUESTS:
 221                 // Increment the EasyList blocked requests count.
 222                 easyListBlockedRequests++;
 223                 break;
 224
 225             case EASY_PRIVACY_BLOCKED_REQUESTS:
 226                 // Increment the EasyPrivacy blocked requests count.
 227                 easyPrivacyBlockedRequests++;
 228                 break;
 229
 230             case FANBOYS_ANNOYANCE_LIST_BLOCKED_REQUESTS:
 231                 // Increment the Fanboy's Annoyance List blocked requests count.
 232                 fanboysAnnoyanceListBlockedRequests++;
 233                 break;
 234
 235             case FANBOYS_SOCIAL_BLOCKING_LIST_BLOCKED_REQUESTS:
 236                 // Increment the Fanboy's Social Blocking List blocked requests count.
 237                 fanboysSocialBlockingListBlockedRequests++;
 238                 break;
 239
 240             case ULTRA_PRIVACY_BLOCKED_REQUESTS:
 241                 // Increment the UltraPrivacy blocked requests count.
 242                 ultraPrivacyBlockedRequests++;
 243                 break;
 244
 245             case THIRD_PARTY_BLOCKED_REQUESTS:
 246                 // Increment the Third Party blocked requests count.
 247                 thirdPartyBlockedRequests++;
 248                 break;
 249         }
 250     }
 251
 252     public int getRequestsCount(int list) {
 253         // Run the command on the indicated list.
 254         switch (list) {
 255             case BLOCKED_REQUESTS:
 256                 // Return the blocked requests count.
 257                 return blockedRequests;
 258
 259             case EASY_LIST_BLOCKED_REQUESTS:
 260                 // Return the EasyList blocked requests count.
 261                 return easyListBlockedRequests;
 262
 263             case EASY_PRIVACY_BLOCKED_REQUESTS:
 264                 // Return the EasyPrivacy blocked requests count.
 265                 return easyPrivacyBlockedRequests;
 266
 267             case FANBOYS_ANNOYANCE_LIST_BLOCKED_REQUESTS:
 268                 // Return the Fanboy's Annoyance List blocked requests count.
 269                 return fanboysAnnoyanceListBlockedRequests;
 270
 271             case FANBOYS_SOCIAL_BLOCKING_LIST_BLOCKED_REQUESTS:
 272                 // Return the Fanboy's Social Blocking List blocked requests count.
 273                 return fanboysSocialBlockingListBlockedRequests;
 274
 275             case ULTRA_PRIVACY_BLOCKED_REQUESTS:
 276                 // Return the UltraPrivacy blocked requests count.
 277                 return ultraPrivacyBlockedRequests;
 278
 279             case THIRD_PARTY_BLOCKED_REQUESTS:
 280                 // Return the Third Party blocked requests count.
 281                 return thirdPartyBlockedRequests;
 282
 283             default:
 284                 // Return 0.  This should never end up being called.
 285                 return 0;
 286         }
 287     }
 288
 289
 290     // Pinned SSL certificates.
 291     public boolean hasPinnedSslCertificate() {
 292         // Return the status of the pinned SSL certificate.
 293         return hasPinnedSslCertificate;
 294     }
 295
 296     public void setPinnedSslCertificate(String issuedToCName, String issuedToOName, String issuedToUName, String issuedByCName, String issuedByOName, String issuedByUName, Date startDate, Date endDate) {
 297         // Store the pinned SSL certificate information.
 298         pinnedSslIssuedToCName = issuedToCName;
 299         pinnedSslIssuedToOName = issuedToOName;
 300         pinnedSslIssuedToUName = issuedToUName;
 301         pinnedSslIssuedByCName = issuedByCName;
 302         pinnedSslIssuedByOName = issuedByOName;
 303         pinnedSslIssuedByUName = issuedByUName;
 304         pinnedSslStartDate = startDate;
 305         pinnedSslEndDate = endDate;
 306
 307         // Set the pinned SSL certificate tracker.
 308         hasPinnedSslCertificate = true;
 309     }
 310
 311     public ArrayList<Object> getPinnedSslCertificate() {
 312         // Initialize an array list.
 313         ArrayList<Object> arrayList = new ArrayList<>();
 314
 315         // Create the SSL certificate string array.
 316         String[] sslCertificateStringArray = new String[] {pinnedSslIssuedToCName, pinnedSslIssuedToOName, pinnedSslIssuedToUName, pinnedSslIssuedByCName, pinnedSslIssuedByOName, pinnedSslIssuedByUName};
 317
 318         // Create the SSL certificate date array.
 319         Date[] sslCertificateDateArray = new Date[] {pinnedSslStartDate, pinnedSslEndDate};
 320
 321         // Add the arrays to the array list.
 322         arrayList.add(sslCertificateStringArray);
 323         arrayList.add(sslCertificateDateArray);
 324
 325         // Return the pinned SSL certificate array list.
 326         return arrayList;
 327     }
 328
 329     public void clearPinnedSslCertificate() {
 330         // Clear the pinned SSL certificate.
 331         pinnedSslIssuedToCName = null;
 332         pinnedSslIssuedToOName = null;
 333         pinnedSslIssuedToUName = null;
 334         pinnedSslIssuedByCName = null;
 335         pinnedSslIssuedByOName = null;
 336         pinnedSslIssuedByUName = null;
 337         pinnedSslStartDate = null;
 338         pinnedSslEndDate = null;
 339
 340         // Clear the pinned SSL certificate tracker.
 341         hasPinnedSslCertificate = false;
 342     }
 343
 344
 345     // Current IP addresses.
 346     public boolean hasCurrentIpAddresses() {
 347         // Return the status of the current IP addresses.
 348         return hasCurrentIpAddresses;
 349     }
 350
 351     public void setCurrentIpAddresses(String ipAddresses) {
 352         // Store the current IP addresses.
 353         currentIpAddresses = ipAddresses;
 354
 355         // Set the current IP addresses tracker.
 356         hasCurrentIpAddresses = true;
 357     }
 358
 359     public String getCurrentIpAddresses() {
 360         // Return the current IP addresses.
 361         return currentIpAddresses;
 362     }
 363
 364     public void clearCurrentIpAddresses() {
 365         // Clear the current IP addresses.
 366         currentIpAddresses = null;
 367
 368         // Clear the current IP addresses tracker.
 369         hasCurrentIpAddresses = false;
 370     }
 371
 372
 373     // Pinned IP addresses.
 374     public boolean hasPinnedIpAddresses() {
 375         // Return the status of the pinned IP addresses.
 376         return hasPinnedIpAddresses;
 377     }
 378
 379     public void setPinnedIpAddresses(String ipAddresses) {
 380         // Store the pinned IP addresses.
 381         pinnedIpAddresses = ipAddresses;
 382
 383         // Set the pinned IP addresses tracker.
 384         hasPinnedIpAddresses = true;
 385     }
 386
 387     public String getPinnedIpAddresses() {
 388         // Return the pinned IP addresses.
 389         return pinnedIpAddresses;
 390     }
 391
 392     public void clearPinnedIpAddresses() {
 393         // Clear the pinned IP addresses.
 394         pinnedIpAddresses = null;
 395
 396         // Clear the pinned IP addresses tracker.
 397         hasPinnedIpAddresses = false;
 398     }
 399
 400
 401     // Ignore pinned information.  The syntax looks better as written, even if it is always inverted.
 402     @SuppressWarnings("BooleanMethodIsAlwaysInverted")
 403     public boolean ignorePinnedDomainInformation() {
 404         // Return the status of the ignore pinned domain information tracker.
 405         return ignorePinnedDomainInformation;
 406     }
 407
 408     public void setIgnorePinnedDomainInformation(boolean status) {
 409         // Set the status of the ignore pinned domain information tracker.
 410         ignorePinnedDomainInformation = status;
 411     }
 412
 413
 414
 415     @Override
 416     public boolean onTouchEvent(MotionEvent motionEvent) {
 417         // Initialize a tracker to return if this motion event is handled.
 418         boolean motionEventHandled;
 419
 420         // Run the commands for the given motion event action.
 421         switch (motionEvent.getAction()) {
 422             case MotionEvent.ACTION_DOWN:
 423                 // Start nested scrolling along the vertical axis.  `ViewCompat` must be used until the minimum API >= 21.
 424                 startNestedScroll(ViewCompat.SCROLL_AXIS_VERTICAL);
 425
 426                 // Save the current Y position.  Action down will not be called again until a new motion starts.
 427                 previousYPosition = (int) motionEvent.getY();
 428
 429                 // Run the default commands.
 430                 motionEventHandled = super.onTouchEvent(motionEvent);
 431                 break;
 432
 433             case MotionEvent.ACTION_MOVE:
 434                 // Get the current Y position.
 435                 int currentYMotionPosition = (int) motionEvent.getY();
 436
 437                 // Calculate the pre-scroll delta Y.
 438                 int preScrollDeltaY = previousYPosition - currentYMotionPosition;
 439
 440                 // Initialize a variable to track how much of the scroll is consumed.
 441                 int[] consumedScroll = new int[2];
 442
 443                 // Initialize a variable to track the offset in the window.
 444                 int[] offsetInWindow = new int[2];
 445
 446                 // Get the WebView Y position.
 447                 int webViewYPosition = getScrollY();
 448
 449                 // Set the scroll delta Y to initially be the same as the pre-scroll delta Y.
 450                 int scrollDeltaY = preScrollDeltaY;
 451
 452                 // Dispatch the nested pre-school.  This scrolls the app bar if it needs it.  `offsetInWindow` will be returned with an updated value.
 453                 if (dispatchNestedPreScroll(0, preScrollDeltaY, consumedScroll, offsetInWindow)) {
 454                     // Update the scroll delta Y if some of it was consumed.
 455                     scrollDeltaY = preScrollDeltaY - consumedScroll[1];
 456                 }
 457
 458                 // Check to see if the WebView is at the top and and the scroll action is downward.
 459                 if ((webViewYPosition == 0) && (scrollDeltaY < 0)) {  // Swipe to refresh is being engaged.
 460                     // Stop the nested scroll so that swipe to refresh has complete control.
 461                     stopNestedScroll();
 462                 } else {  // Swipe to refresh is not being engaged.
 463                     // Start the nested scroll so that the app bar can scroll off the screen.
 464                     startNestedScroll(ViewCompat.SCROLL_AXIS_VERTICAL);
 465
 466                     // Dispatch the nested scroll.  This scrolls the WebView.  The delta Y unconsumed normally controls the swipe refresh layout, but that is handled with the `if` statement above.
 467                     dispatchNestedScroll(0, scrollDeltaY, 0, 0, offsetInWindow);
 468
 469                     // Store the current Y position for use in the next action move.
 470                     previousYPosition = previousYPosition - scrollDeltaY;
 471                 }
 472
 473                 // Run the default commands.
 474                 motionEventHandled = super.onTouchEvent(motionEvent);
 475                 break;
 476
 477
 478             default:
 479                 // Stop nested scrolling.
 480                 stopNestedScroll();
 481
 482                 // Run the default commands.
 483                 motionEventHandled = super.onTouchEvent(motionEvent);
 484         }
 485
 486         // Perform a click.  This is required by the Android accessibility guidelines.
 487         performClick();
 488
 489         // Return the status of the motion event.
 490         return motionEventHandled;
 491     }
 492
 493     // The Android accessibility guidelines require overriding `performClick()` and calling it from `onTouchEvent()`.
 494     @Override
 495     public boolean performClick() {
 496         return super.performClick();
 497     }
 498
 499
 500     // Method from NestedScrollingChild.
 501     @Override
 502     public void setNestedScrollingEnabled(boolean status) {
 503         // Set the status of the nested scrolling.
 504         nestedScrollingChildHelper.setNestedScrollingEnabled(status);
 505     }
 506
 507     // Method from NestedScrollingChild.
 508     @Override
 509     public boolean isNestedScrollingEnabled() {
 510         // Return the status of nested scrolling.
 511         return nestedScrollingChildHelper.isNestedScrollingEnabled();
 512     }
 513
 514
 515     // Method from NestedScrollingChild.
 516     @Override
 517     public boolean startNestedScroll(int axes) {
 518         // Start a nested scroll along the indicated axes.
 519         return nestedScrollingChildHelper.startNestedScroll(axes);
 520     }
 521
 522     // Method from NestedScrollingChild2.
 523     @Override
 524     public boolean startNestedScroll(int axes, int type) {
 525         // Start a nested scroll along the indicated axes for the given type of input which caused the scroll event.
 526         return nestedScrollingChildHelper.startNestedScroll(axes, type);
 527     }
 528
 529
 530     // Method from NestedScrollingChild.
 531     @Override
 532     public void stopNestedScroll() {
 533         // Stop the nested scroll.
 534         nestedScrollingChildHelper.stopNestedScroll();
 535     }
 536
 537     // Method from NestedScrollingChild2.
 538     @Override
 539     public void stopNestedScroll(int type) {
 540         // Stop the nested scroll of the given type of input which caused the scroll event.
 541         nestedScrollingChildHelper.stopNestedScroll(type);
 542     }
 543
 544
 545     // Method from NestedScrollingChild.
 546     @Override
 547     public boolean hasNestedScrollingParent() {
 548         // Return the status of the nested scrolling parent.
 549         return nestedScrollingChildHelper.hasNestedScrollingParent();
 550     }
 551
 552     // Method from NestedScrollingChild2.
 553     @Override
 554     public boolean hasNestedScrollingParent(int type) {
 555         // return the status of the nested scrolling parent for the given type of input which caused the scroll event.
 556         return nestedScrollingChildHelper.hasNestedScrollingParent(type);
 557     }
 558
 559
 560     // Method from NestedScrollingChild.
 561     @Override
 562     public boolean dispatchNestedPreScroll(int deltaX, int deltaY, int[] consumed, int[] offsetInWindow) {
 563         // Dispatch a nested pre-scroll with the specified deltas, which lets a parent to consume some of the scroll if desired.
 564         return nestedScrollingChildHelper.dispatchNestedPreScroll(deltaX, deltaY, consumed, offsetInWindow);
 565     }
 566
 567     // Method from NestedScrollingChild2.
 568     @Override
 569     public boolean dispatchNestedPreScroll(int deltaX, int deltaY, int[] consumed, int[] offsetInWindow, int type) {
 570         // Dispatch a nested pre-scroll with the specified deltas for the given type of input which caused the scroll event, which lets a parent to consume some of the scroll if desired.
 571         return nestedScrollingChildHelper.dispatchNestedPreScroll(deltaX, deltaY, consumed, offsetInWindow, type);
 572     }
 573
 574
 575     // Method from NestedScrollingChild.
 576     @Override
 577     public boolean dispatchNestedScroll(int deltaXConsumed, int deltaYConsumed, int deltaXUnconsumed, int deltaYUnconsumed, int[] offsetInWindow) {
 578         // Dispatch a nested scroll with the specified deltas.
 579         return nestedScrollingChildHelper.dispatchNestedScroll(deltaXConsumed, deltaYConsumed, deltaXUnconsumed, deltaYUnconsumed, offsetInWindow);
 580     }
 581
 582     // Method from NestedScrollingChild2.
 583     @Override
 584     public boolean dispatchNestedScroll(int deltaXConsumed, int deltaYConsumed, int deltaXUnconsumed, int deltaYUnconsumed, int[] offsetInWindow, int type) {
 585         // Dispatch a nested scroll with the specified deltas for the given type of input which caused the scroll event.
 586         return nestedScrollingChildHelper.dispatchNestedScroll(deltaXConsumed, deltaYConsumed, deltaXUnconsumed, deltaYUnconsumed, offsetInWindow, type);
 587     }
 588
 589
 590     // Method from NestedScrollingChild.
 591     @Override
 592     public boolean dispatchNestedPreFling(float velocityX, float velocityY) {
 593         // Dispatch a nested pre-fling with the specified velocity, which lets a parent consume the fling if desired.
 594         return nestedScrollingChildHelper.dispatchNestedPreFling(velocityX, velocityY);
 595     }
 596
 597     // Method from NestedScrollingChild.
 598     @Override
 599     public boolean dispatchNestedFling(float velocityX, float velocityY, boolean consumed) {
 600         // Dispatch a nested fling with the specified velocity.
 601         return nestedScrollingChildHelper.dispatchNestedFling(velocityX, velocityY, consumed);
 602     }
 603 }