react-native-webview-bootpay 11.22.86 → 11.26.18

package/android/src/main/AndroidManifest.xml

@@ -3,7 +3,7 @@
 
   <application>
     <provider
-      android:name="kr.co.bootpay.webview.BPCWebViewFileProvider"
+      android:name=".BPCWebViewFileProvider"
       android:authorities="${applicationId}.fileprovider"
       android:exported="false"
       android:grantUriPermissions="true">

package/android/src/main/java/kr/co/bootpay/webview/BPCWebChromeClient.java

@@ -42,6 +42,7 @@ import java.util.List;
 
 import kr.co.bootpay.webview.events.TopLoadingProgressEvent;
 
+
 class BPCWebChromeClient extends WebChromeClient implements LifecycleEventListener {
   protected static final FrameLayout.LayoutParams FULLSCREEN_LAYOUT_PARAMS = new FrameLayout.LayoutParams(
     ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT, Gravity.CENTER);
@@ -86,24 +87,28 @@ class BPCWebChromeClient extends WebChromeClient implements LifecycleEventListen
 
   protected BPCWebView.ProgressChangedFilter progressChangedFilter = null;
 
+  // True if protected media should be allowed, false otherwise
+  protected boolean mAllowsProtectedMedia = false;
+
   public BPCWebChromeClient(ReactContext reactContext, WebView webView) {
     this.mReactContext = reactContext;
     this.mWebView = webView;
   }
 
+
   /** bootpay change **/
 
   @Override
   public void onCloseWindow(WebView window) {
     super.onCloseWindow(window);
     ((BPCWebView) window).dissmissDialog();
-
 //    if(mainView != null) {
 //      mainView.removeView(window);
 //    }
 //    window.setVisibility(View.GONE);
   }
 
+
   void setWebSettingCopy(WebView view, WebView newWebView) {
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
       newWebView.getSettings().setMediaPlaybackRequiresUserGesture( view.getSettings().getMediaPlaybackRequiresUserGesture() );
@@ -158,20 +163,13 @@ class BPCWebChromeClient extends WebChromeClient implements LifecycleEventListen
     }
   }
 
-//  WebView mainView;
   @Override
   public boolean onCreateWindow(WebView view, boolean isDialog, boolean isUserGesture, Message resultMsg) {
-
-
-
-
     final BPCWebView newWebView = new BPCWebView((ThemedReactContext) view.getContext());
     BPCWebChromeClient client = new BPCWebChromeClient(this.mReactContext, view);
 //    client.onCloseWindow();
     client.setProgressChangedFilter(progressChangedFilter);
-
     newWebView.setWebChromeClient(client);
-
     setWebSettingCopy(view, newWebView);
 
     newWebView.setWebViewClient(new BPCWebViewClient() {
@@ -213,12 +211,15 @@ class BPCWebChromeClient extends WebChromeClient implements LifecycleEventListen
     resultMsg.sendToTarget();
 
     return true;
-//    final WebView newWebView = new WebView(view.getContext());
-//    final WebView.WebViewTransport transport = (WebView.WebViewTransport) resultMsg.obj;
-//    transport.setWebView(newWebView);
-//    resultMsg.sendToTarget();
-//
-//    return true;
+
+    /*
+    final WebView newWebView = new WebView(view.getContext());
+    final WebView.WebViewTransport transport = (WebView.WebViewTransport) resultMsg.obj;
+    transport.setWebView(newWebView);
+    resultMsg.sendToTarget();
+
+    return true;
+    */
   }
 
   @Override
@@ -266,9 +267,20 @@ class BPCWebChromeClient extends WebChromeClient implements LifecycleEventListen
       } else if (requestedResource.equals(PermissionRequest.RESOURCE_VIDEO_CAPTURE)) {
         androidPermission = Manifest.permission.CAMERA;
       } else if(requestedResource.equals(PermissionRequest.RESOURCE_PROTECTED_MEDIA_ID)) {
-        androidPermission = PermissionRequest.RESOURCE_PROTECTED_MEDIA_ID;
+        if (mAllowsProtectedMedia) {
+          grantedPermissions.add(requestedResource);
+        } else {
+          /**
+           * Legacy handling (Kept in case it was working under some conditions (given Android version or something))
+           *
+           * Try to ask user to grant permission using Activity.requestPermissions
+           *
+           * Find more details here: https://github.com/react-native-webview/react-native-webview/pull/2732
+           */
+          androidPermission = PermissionRequest.RESOURCE_PROTECTED_MEDIA_ID;
+        }
       }
-      // TODO: RESOURCE_MIDI_SYSEX, RESOURCE_PROTECTED_MEDIA_ID.
+      // TODO: RESOURCE_MIDI_SYSEX.
 
       if (androidPermission != null) {
         if (ContextCompat.checkSelfPermission(mReactContext, androidPermission) == PackageManager.PERMISSION_GRANTED) {
@@ -458,4 +470,13 @@ class BPCWebChromeClient extends WebChromeClient implements LifecycleEventListen
   public void setProgressChangedFilter(BPCWebView.ProgressChangedFilter filter) {
     progressChangedFilter = filter;
   }
-}
+
+  /**
+   * Set whether or not protected media should be allowed
+   * /!\ Setting this to false won't revoke permission already granted to the current webpage.
+   * In order to do so, you'd need to reload the page /!\
+   */
+  public void setAllowsProtectedMedia(boolean enabled) {
+    mAllowsProtectedMedia = enabled;
+  }
+}

package/android/src/main/java/kr/co/bootpay/webview/BPCWebView.java

@@ -32,7 +32,6 @@ import java.io.UnsupportedEncodingException;
 import java.net.URLEncoder;
 
 import kr.co.bootpay.webview.events.TopMessageEvent;
-
 /**
  * Subclass of {@link WebView} that implements {@link LifecycleEventListener} interface in order
  * to call {@link WebView#destroy} on activity destroy event and also to clear the client

package/android/src/main/java/kr/co/bootpay/webview/BPCWebViewClient.java

@@ -177,11 +177,9 @@ class BPCWebViewClient extends WebViewClient {
     basicAuthCredential = credential;
   }
 
-  /** bootpay changed  **/
   @Override
   public void onPageFinished(WebView webView, String url) {
     super.onPageFinished(webView, url);
-    updateBlindViewIfNaverLogin(webView, url);
 
     if (!mLastLoadFailed) {
       BPCWebView reactWebView = (BPCWebView) webView;
@@ -207,14 +205,12 @@ class BPCWebViewClient extends WebViewClient {
         createWebViewEvent(webView, url)));
   }
 
-  /** bootpay changed  **/
 
   @Override
   public boolean shouldOverrideUrlLoading(WebView view, String url) {
     Intent intent = getIntentWithPackage(url);
     Context context = view.getContext();
-
-    Log.d("bootpay", "shouldOverrideUrlLoading : " + url);
+ 
 
     if(isIntent(url)) {
       if(isInstallApp(intent, context)) return startApp(intent, context);
@@ -229,20 +225,19 @@ class BPCWebViewClient extends WebViewClient {
 //      return url.contains("vguardend");
     return shouldOverrideUrlLoadingRN(view, url);
   }
-
-
-  private boolean shouldOverrideUrlLoadingRN(WebView view, String url) {
-    final BPCWebView bpcWebView = (BPCWebView) view;
+ 
+  public boolean shouldOverrideUrlLoadingRN(WebView view, String url) {
+    final BPCWebView BPCWebView = (BPCWebView) view;
     final boolean isJsDebugging = ((ReactContext) view.getContext()).getJavaScriptContextHolder().get() == 0;
 
-    if (!isJsDebugging && bpcWebView.mCatalystInstance != null) {
+    if (!isJsDebugging && BPCWebView.mCatalystInstance != null) {
       final Pair<Integer, AtomicReference<BPCWebViewModule.ShouldOverrideUrlLoadingLock.ShouldOverrideCallbackState>> lock = BPCWebViewModule.shouldOverrideUrlLoadingLock.getNewLock();
       final int lockIdentifier = lock.first;
       final AtomicReference<BPCWebViewModule.ShouldOverrideUrlLoadingLock.ShouldOverrideCallbackState> lockObject = lock.second;
 
       final WritableMap event = createWebViewEvent(view, url);
       event.putInt("lockIdentifier", lockIdentifier);
-      bpcWebView.sendDirectMessage("onShouldStartLoadWithRequest", event);
+      BPCWebView.sendDirectMessage("onShouldStartLoadWithRequest", event);
 
       try {
         assert lockObject != null;

package/android/src/main/java/kr/co/bootpay/webview/BPCWebViewManager.java

@@ -1,43 +1,82 @@
 package kr.co.bootpay.webview;
 
+import android.annotation.SuppressLint;
 import android.annotation.TargetApi;
 import android.app.Activity;
 import android.app.DownloadManager;
 import android.content.Context;
 import android.content.pm.ActivityInfo;
+import android.content.pm.PackageManager;
 import android.graphics.Bitmap;
 import android.graphics.Color;
+import android.Manifest;
+import android.net.http.SslError;
 import android.net.Uri;
 import android.os.Build;
 import android.os.Environment;
+import android.os.Message;
+import android.os.SystemClock;
+import android.text.TextUtils;
 import android.util.Log;
+import android.view.Gravity;
+import android.view.MotionEvent;
 import android.view.View;
 import android.view.ViewGroup;
 import android.view.ViewGroup.LayoutParams;
 import android.view.WindowManager;
+import android.webkit.ConsoleMessage;
 import android.webkit.CookieManager;
 import android.webkit.DownloadListener;
-import android.webkit.URLUtil;
+import android.webkit.GeolocationPermissions;
+import android.webkit.HttpAuthHandler;
+import android.webkit.JavascriptInterface;
+import android.webkit.RenderProcessGoneDetail;
+import android.webkit.SslErrorHandler;
+import android.webkit.PermissionRequest;
+import android.webkit.ValueCallback;
+import android.webkit.WebChromeClient;
+import android.webkit.WebResourceRequest;
+import android.webkit.WebResourceResponse;
 import android.webkit.WebSettings;
 import android.webkit.WebView;
+import android.webkit.WebViewClient;
+import android.widget.FrameLayout;
 
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.core.content.ContextCompat;
+import androidx.core.util.Pair;
 import androidx.webkit.WebSettingsCompat;
 import androidx.webkit.WebViewFeature;
 
+import com.facebook.common.logging.FLog;
+import com.facebook.react.modules.core.PermissionAwareActivity;
+import com.facebook.react.modules.core.PermissionListener;
+import com.facebook.react.views.scroll.ScrollEvent;
 import com.facebook.react.views.scroll.ScrollEventType;
+import com.facebook.react.views.scroll.OnScrollDispatchHelper;
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.CatalystInstance;
+import com.facebook.react.bridge.LifecycleEventListener;
 import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.ReadableMapKeySetIterator;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.WritableNativeArray;
+import com.facebook.react.bridge.WritableNativeMap;
 import com.facebook.react.common.MapBuilder;
 import com.facebook.react.common.build.ReactBuildConfig;
 import com.facebook.react.module.annotations.ReactModule;
 import com.facebook.react.uimanager.SimpleViewManager;
 import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.UIManagerModule;
 import com.facebook.react.uimanager.annotations.ReactProp;
-
+import com.facebook.react.uimanager.events.ContentSizeChangeEvent;
+import com.facebook.react.uimanager.events.Event;
+import com.facebook.react.uimanager.events.EventDispatcher;
+import kr.co.bootpay.webview.BPCWebViewModule.ShouldOverrideUrlLoadingLock.ShouldOverrideCallbackState;
 import kr.co.bootpay.webview.events.TopLoadingErrorEvent;
 import kr.co.bootpay.webview.events.TopHttpErrorEvent;
 import kr.co.bootpay.webview.events.TopLoadingFinishEvent;
@@ -54,9 +93,14 @@ import java.io.UnsupportedEncodingException;
 import java.lang.IllegalArgumentException;
 import java.net.MalformedURLException;
 import java.net.URL;
+import java.net.URLEncoder;
+import java.util.ArrayList;
+import java.util.Collections;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Locale;
 import java.util.Map;
+import java.util.concurrent.atomic.AtomicReference;
 
 /**
  * Manages instances of {@link WebView}
@@ -116,6 +160,7 @@ public class BPCWebViewManager extends SimpleViewManager<WebView> {
 
   protected BPCWebChromeClient mWebChromeClient = null;
   protected boolean mAllowsFullscreenVideo = false;
+  protected boolean mAllowsProtectedMedia = false;
   protected @Nullable String mUserAgent = null;
   protected @Nullable String mUserAgentWithApplicationName = null;
   protected @Nullable String mDownloadingMessage = null;
@@ -268,14 +313,7 @@ public class BPCWebViewManager extends SimpleViewManager<WebView> {
 
   @ReactProp(name = "cacheEnabled")
   public void setCacheEnabled(WebView view, boolean enabled) {
-    if (enabled) {
-      Context ctx = view.getContext();
-      if (ctx != null) {
-        view.getSettings().setCacheMode(WebSettings.LOAD_DEFAULT);
-      }
-    } else {
-      view.getSettings().setCacheMode(WebSettings.LOAD_NO_CACHE);
-    }
+    view.getSettings().setCacheMode(enabled ? WebSettings.LOAD_DEFAULT : WebSettings.LOAD_NO_CACHE);
   }
 
   @ReactProp(name = "cacheMode")
@@ -632,6 +670,20 @@ public class BPCWebViewManager extends SimpleViewManager<WebView> {
     view.getSettings().setMinimumFontSize(fontSize);
   }
 
+  @ReactProp(name = "allowsProtectedMedia")
+  public void setAllowsProtectedMedia(WebView view, boolean enabled) {
+    // This variable is used to keep consistency
+    // in case a new WebChromeClient is created
+    // (eg. when mAllowsFullScreenVideo changes)
+    mAllowsProtectedMedia = enabled;
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        WebChromeClient client = view.getWebChromeClient();
+        if (client != null && client instanceof BPCWebChromeClient) {
+            ((BPCWebChromeClient) client).setAllowsProtectedMedia(enabled);
+        }
+    }
+  }
+
   @Override
   protected void addEventEmitters(ThemedReactContext reactContext, WebView view) {
     // Do not register default touch emitter and let WebView implementation handle touches
@@ -837,7 +889,7 @@ public class BPCWebViewManager extends SimpleViewManager<WebView> {
           mReactContext.removeLifecycleEventListener(this);
         }
       };
-
+      
       webView.setWebChromeClient(mWebChromeClient);
     } else {
       if (mWebChromeClient != null) {
@@ -850,9 +902,8 @@ public class BPCWebViewManager extends SimpleViewManager<WebView> {
           return Bitmap.createBitmap(50, 50, Bitmap.Config.ARGB_8888);
         }
       };
-
-      webView.setWebChromeClient(mWebChromeClient);
     }
+    mWebChromeClient.setAllowsProtectedMedia(mAllowsProtectedMedia);
+    webView.setWebChromeClient(mWebChromeClient);
   }
-
 }

package/android/src/main/java/kr/co/bootpay/webview/URLUtil.java

@@ -0,0 +1,179 @@
+/*
+ * Copyright (C) 2006 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * The source code is obtained from the Android SDK Sources (API level 31),
+ * and modified by UNIDY2002 <UNIDY2002@outlook.com>.
+ *
+ * Change list:
+ * - Remove all unused class members except guessFileName,
+ *   CONTENT_DISPOSITION_PATTERN and parseContentDisposition
+ * - Improve CONTENT_DISPOSITION_PATTERN and parseContentDisposition to add
+ *   support for the "filename*" parameter in content disposition
+ */
+
+package kr.co.bootpay.webview;
+
+import android.net.Uri;
+import android.webkit.MimeTypeMap;
+import androidx.annotation.Nullable;
+
+import java.io.UnsupportedEncodingException;
+import java.net.URLDecoder;
+import java.util.Locale;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public final class URLUtil {
+    /**
+     * Guesses canonical filename that a download would have, using
+     * the URL and contentDisposition. File extension, if not defined,
+     * is added based on the mimetype
+     * @param url Url to the content
+     * @param contentDisposition Content-Disposition HTTP header or {@code null}
+     * @param mimeType Mime-type of the content or {@code null}
+     *
+     * @return suggested filename
+     */
+    public static final String guessFileName(
+            String url,
+            @Nullable String contentDisposition,
+            @Nullable String mimeType) {
+        String filename = null;
+        String extension = null;
+
+        // If we couldn't do anything with the hint, move toward the content disposition
+        if (filename == null && contentDisposition != null) {
+            filename = parseContentDisposition(contentDisposition);
+            if (filename != null) {
+                int index = filename.lastIndexOf('/') + 1;
+                if (index > 0) {
+                    filename = filename.substring(index);
+                }
+            }
+        }
+
+        // If all the other http-related approaches failed, use the plain uri
+        if (filename == null) {
+            String decodedUrl = Uri.decode(url);
+            if (decodedUrl != null) {
+                int queryIndex = decodedUrl.indexOf('?');
+                // If there is a query string strip it, same as desktop browsers
+                if (queryIndex > 0) {
+                    decodedUrl = decodedUrl.substring(0, queryIndex);
+                }
+                if (!decodedUrl.endsWith("/")) {
+                    int index = decodedUrl.lastIndexOf('/') + 1;
+                    if (index > 0) {
+                        filename = decodedUrl.substring(index);
+                    }
+                }
+            }
+        }
+
+        // Finally, if couldn't get filename from URI, get a generic filename
+        if (filename == null) {
+            filename = "downloadfile";
+        }
+
+        // Split filename between base and extension
+        // Add an extension if filename does not have one
+        int dotIndex = filename.indexOf('.');
+        if (dotIndex < 0) {
+            if (mimeType != null) {
+                extension = MimeTypeMap.getSingleton().getExtensionFromMimeType(mimeType);
+                if (extension != null) {
+                    extension = "." + extension;
+                }
+            }
+            if (extension == null) {
+                if (mimeType != null && mimeType.toLowerCase(Locale.ROOT).startsWith("text/")) {
+                    if (mimeType.equalsIgnoreCase("text/html")) {
+                        extension = ".html";
+                    } else {
+                        extension = ".txt";
+                    }
+                } else {
+                    extension = ".bin";
+                }
+            }
+        } else {
+            if (mimeType != null) {
+                // Compare the last segment of the extension against the mime type.
+                // If there's a mismatch, discard the entire extension.
+                int lastDotIndex = filename.lastIndexOf('.');
+                String typeFromExt = MimeTypeMap.getSingleton().getMimeTypeFromExtension(
+                        filename.substring(lastDotIndex + 1));
+                if (typeFromExt != null && !typeFromExt.equalsIgnoreCase(mimeType)) {
+                    extension = MimeTypeMap.getSingleton().getExtensionFromMimeType(mimeType);
+                    if (extension != null) {
+                        extension = "." + extension;
+                    }
+                }
+            }
+            if (extension == null) {
+                extension = filename.substring(dotIndex);
+            }
+            filename = filename.substring(0, dotIndex);
+        }
+
+        return filename + extension;
+    }
+
+    /** Regex used to parse content-disposition headers */
+    private static final Pattern CONTENT_DISPOSITION_PATTERN =
+            Pattern.compile("attachment(?:;\\s*filename\\s*=\\s*(\"?)([^\"]*)\\1)?(?:;\\s*filename\\s*\\*\\s*=\\s*([^']*)'[^']*'([^']*))?\\s*$",
+            Pattern.CASE_INSENSITIVE);
+
+    /**
+     * Parse the Content-Disposition HTTP Header. The format of the header
+     * is defined here: <a href="https://www.rfc-editor.org/rfc/rfc6266">RFC 6266</a>
+     * This header provides a filename for content that is going to be
+     * downloaded to the file system. We only support the attachment type.
+     */
+    static String parseContentDisposition(String contentDisposition) {
+        try {
+            // The regex attempts to match the following pattern:
+            //     attachment; filename="(Group 2)"; filename*=(Group 3)'(lang)'(Group 4)
+            // Group 4 refers to the percent-encoded filename, and the charset
+            // is specified in Group 3.
+            // Group 2 is the fallback filename.
+            // Group 1 refers to the quotation marks around Group 2.
+            //
+            // Test cases can be found at http://test.greenbytes.de/tech/tc2231/
+            // Examples can be found at https://www.rfc-editor.org/rfc/rfc6266#section-5
+            // There are a few known limitations:
+            // - any Content Disposition value that does not have parameters
+            //   arranged in the order of "attachment...filename...filename*"
+            //   or contains extra parameters shall fail to be parsed
+            // - any filename that contains " shall fail to be parsed
+            Matcher m = CONTENT_DISPOSITION_PATTERN.matcher(contentDisposition);
+            if (m.find()) {
+                if (m.group(3) != null && m.group(4) != null) {
+                    try {
+                        return URLDecoder.decode(m.group(4), m.group(3).isEmpty() ? "UTF-8" : m.group(3));
+                    } catch (UnsupportedEncodingException e) {
+                        // Skip the ext-parameter as the encoding is unsupported
+                    }
+                }
+                return m.group(2);
+            }
+        } catch (IllegalStateException ex) {
+             // This function is defined as returning null when it can't parse the header
+        }
+        return null;
+    }
+}

package/apple/BPCWebView.h

@@ -37,7 +37,6 @@ shouldStartLoadForRequest:(NSMutableDictionary<NSString *, id> *_Nonnull)request
 
 @interface BPCWebView : RCTView
 
-@property NSString* beforeUrl;
 @property (nonatomic, weak) id<BPCWebViewDelegate> _Nullable delegate;
 @property (nonatomic, copy) NSDictionary * _Nullable source;
 @property (nonatomic, assign) BOOL messagingEnabled;
@@ -102,6 +101,8 @@ shouldStartLoadForRequest:(NSMutableDictionary<NSString *, id> *_Nonnull)request
 @property (nonatomic, assign) BPCWebViewPermissionGrantType mediaCapturePermissionGrantType;
 #endif
 
+@property (nonatomic, copy) NSString * _Nullable beforeUrl;
+
 + (void)setClientAuthenticationCredential:(nullable NSURLCredential*)credential;
 + (void)setCustomCertificatesForHost:(nullable NSDictionary *)certificates;
 - (void)postMessage:(NSString *_Nullable)message;
@@ -116,6 +117,7 @@ shouldStartLoadForRequest:(NSMutableDictionary<NSString *, id> *_Nonnull)request
 - (void)pullToRefresh:(UIRefreshControl *_Nonnull)refreshControl;
 #endif
 
+
 - (void)                  webViewRN:(WKWebView *)webView
   decidePolicyForNavigationAction:(WKNavigationAction *)navigationAction
                     decisionHandler:(void (^)(WKNavigationActionPolicy))decisionHandler;