Java Examples for android.webkit.WebResourceRequest

private void configureWebViewClient() {
    loginWebview.setWebViewClient(new WebViewClient() {

        @SuppressWarnings("deprecation")
        @Override
        public boolean shouldOverrideUrlLoading(WebView view, String url) {
            return handleUrl(Uri.parse(url)) || super.shouldOverrideUrlLoading(view, url);
        }

        @TargetApi(Build.VERSION_CODES.N)
        @Override
        public boolean shouldOverrideUrlLoading(WebView view, WebResourceRequest request) {
            final Uri uri = request.getUrl();
            return handleUrl(uri) || super.shouldOverrideUrlLoading(view, request);
        }

        private boolean handleUrl(Uri uri) {
            String redirectURL = getIntent().getStringExtra(EXTRA_REDIRECT_URL);
            if (uri.toString().startsWith(redirectURL)) {
                String code = uri.getQueryParameter("code");
                return makeResult(code);
            }
            return false;
        }

        private boolean makeResult(String code) {
            if (code != null && !code.isEmpty()) {
                Intent result = new Intent();
                result.putExtra(RESULT_CODE, code);
                setResult(RESULT_OK, result);
                finish();
                return true;
            }
            finish();
            return false;
        }
    });
}

@Override
protected void initViews() {
    setSupportActionBar(mToolbar);
    getSupportActionBar().setDisplayHomeAsUpEnabled(true);
    WebSettings webSettings = mWebView.getSettings();
    webSettings.setJavaScriptEnabled(true);
    mWebView.setWebViewClient(new WebViewClient() {

        @Override
        public boolean shouldOverrideUrlLoading(WebView view, WebResourceRequest request) {
            view.loadUrl(request.getUrl().toString());
            return true;
        }
    });
    mWebView.setWebChromeClient(new WebChromeClient() {

        @Override
        public void onReceivedTitle(WebView view, String title) {
            mToolbar.setTitle(title);
        }
    });
    if (!TextUtils.isEmpty(mUrl)) {
        mWebView.loadUrl(mUrl);
    }
}

@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
    // The last two arguments ensure LayoutParams are inflated
    // properly.
    View rootView = inflater.inflate(R.layout.fragment_pager_layout, container, false);
    mProgressBar = (ProgressBar) rootView.findViewById(R.id.progress);
    mTLRLinearLayout = (TLRLinearLayout) rootView.findViewById(R.id.tlrlayout);
    mTLRLinearLayout.addTLRUiHandler(new TLRUIHandlerAdapter() {

        @Override
        public void onRefreshStatusChanged(View target, TLRLinearLayout.RefreshStatus status) {
            if (status == TLRLinearLayout.RefreshStatus.REFRESHING) {
                mWebView.loadUrl("https://github.com/borneywpf");
            }
        }
    });
    mWebView = (WebView) rootView.findViewById(R.id.content);
    mWebView.setWebViewClient(new WebViewClient() {

        @Override
        public void onPageFinished(WebView view, String url) {
            super.onPageFinished(view, url);
            mTLRLinearLayout.finishRefresh(true);
        }

        @Override
        public void onReceivedError(WebView view, WebResourceRequest request, WebResourceError error) {
            super.onReceivedError(view, request, error);
            mHandler.postDelayed(new Runnable() {

                @Override
                public void run() {
                    mTLRLinearLayout.finishRefresh(false);
                }
            }, 1500);
        }
    });
    mWebView.setWebChromeClient(new WebChromeClient() {

        @Override
        public void onProgressChanged(WebView view, int newProgress) {
            super.onProgressChanged(view, newProgress);
            if (newProgress == 0 || newProgress == 100) {
                mProgressBar.setVisibility(View.GONE);
            } else {
                mProgressBar.setVisibility(View.VISIBLE);
            }
            mProgressBar.setProgress(newProgress);
        }
    });
    return rootView;
}

@Override
public void render() {
    Log.d(TAG, "I am IFrameView " + getLink());
    setLayoutParams(new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT));
    setPadding(0, 0, 0, Utils.dpToPx(this.getContext(), 16));
    WebView webView = new WebView(getContext());
    webView.setWebViewClient(new WebViewClient() {

        @Override
        public boolean shouldOverrideUrlLoading(WebView view, WebResourceRequest request) {
            return false;
        }
    });
    webView.getSettings().setPluginState(WebSettings.PluginState.ON);
    webView.getSettings().setJavaScriptEnabled(true);
    getElement().attr("width", "100%");
    webView.loadData(getElement().toString(), "text/html", null);
    webView.setLayoutParams(new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT));
    addView(webView);
}

@Override
public void onViewCreated(View view, Bundle savedInstanceState) {
    super.onViewCreated(view, savedInstanceState);
    swipeToLoadLayout = (SwipeToLoadLayout) view.findViewById(R.id.swipeToLoadLayout);
    webView = (WebView) view.findViewById(R.id.swipe_target);
    swipeToLoadLayout.setOnRefreshListener(this);
    swipeToLoadLayout.setOnLoadMoreListener(this);
    webView.setWebViewClient(new WebViewClient() {

        @Override
        public void onPageFinished(WebView view, String url) {
            super.onPageFinished(view, url);
            swipeToLoadLayout.setRefreshing(false);
        }

        @Override
        public void onReceivedError(WebView view, WebResourceRequest request, WebResourceError error) {
            super.onReceivedError(view, request, error);
            swipeToLoadLayout.setRefreshing(false);
        }

        @Override
        public void onReceivedHttpError(WebView view, WebResourceRequest request, WebResourceResponse errorResponse) {
            super.onReceivedHttpError(view, request, errorResponse);
            swipeToLoadLayout.setRefreshing(false);
        }
    });
}

@NonNull
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public WebRequest toGenericRequest(final WebResourceRequest request) {
    return new WebRequest() {

        @NonNull
        @Override
        public String getUrl() {
            return request.getUrl().toString();
        }

        @Nullable
        @Override
        public String getMethod() {
            return request.getMethod();
        }

        @NonNull
        @Override
        public Map<String, String> getRequestHeaders() {
            return request.getRequestHeaders();
        }
    };
}

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_web_view);
    ButterKnife.bind(this);
    webviewTitle = this.getIntent().getStringExtra(AppConstants.WEBVIEW_TITLE);
    webviewUrl = this.getIntent().getStringExtra(AppConstants.WEBVIEW_URL);
    webviewUrlData = this.getIntent().getStringExtra(AppConstants.WEBVIEW_URL_DATA);
    initToolbar(webviewTitle);
    if (!TextUtils.isEmpty(webviewUrl)) {
        webview.loadUrl(webviewUrl);
    }
    if (!TextUtils.isEmpty(webviewUrlData)) {
        webview.loadData(webviewUrlData, "text/html; charset=UTF-8", null);
    }
    LogUtil.d("webviewUrl=" + webviewUrl);
    WebSettings webSettings = webview.getSettings();
    webSettings.setJavaScriptEnabled(true);
    webview.setWebViewClient(new WebViewClient() {

        @Override
        public void onPageStarted(WebView view, String url, Bitmap favicon) {
            super.onPageStarted(view, url, favicon);
        }

        @Override
        public void onPageFinished(WebView view, String url) {
            super.onPageFinished(view, url);
            LogUtil.d("onPageFinished=");
        }

        @Override
        public void onReceivedHttpError(WebView view, WebResourceRequest request, WebResourceResponse errorResponse) {
            super.onReceivedHttpError(view, request, errorResponse);
            LogUtil.d("onReceivedHttpError");
        }

        @Override
        public boolean shouldOverrideUrlLoading(WebView view, String url) {
            webview.setVisibility(View.VISIBLE);
            LogUtil.d("shouldOverrideUrlLoading");
            //                        return super.shouldOverrideUrlLoading(view, url);
            return true;
        }

        @Override
        public void onReceivedError(WebView view, int errorCode, String description, String failingUrl) {
            // Handle the error
            LogUtil.d("onReceivedError errorCode=" + errorCode);
            webview.setVisibility(View.GONE);
        }

        @Override
        public void onReceivedError(WebView view, WebResourceRequest request, WebResourceError error) {
            super.onReceivedError(view, request, error);
        //表示此方法无效
        }
    });
}

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    mBinding = DataBindingUtil.setContentView(this, R.layout.activity_terms_and_conditions);
    mBinding.btnAgree.setOnClickListener(this);
    mBinding.scrollView.getSettings().setJavaScriptEnabled(true);
    mBinding.scrollView.loadUrl("https://cdn.rawgit.com/alphamu/PrayTime-Android/a6f942f9/privacypolicy.html");
    mBinding.scrollView.setWebViewClient(new WebViewClient() {

        boolean success = true;

        @Override
        public boolean shouldOverrideUrlLoading(WebView view, String url) {
            return true;
        }

        @Override
        public boolean shouldOverrideUrlLoading(WebView view, WebResourceRequest request) {
            return true;
        }

        @Override
        public void onPageStarted(WebView view, String url, Bitmap favicon) {
            success = true;
        }

        @Override
        public void onPageFinished(WebView view, String url) {
            mBinding.btnAgree.setEnabled(success);
        }

        @Override
        public void onReceivedError(WebView view, WebResourceRequest request, WebResourceError error) {
            mBinding.btnAgree.setEnabled(success);
        }
    });
    if (getIntent().hasExtra(EXTRA_DISPLAY_ONLY) && getIntent().getBooleanExtra(EXTRA_DISPLAY_ONLY, false)) {
        mBinding.btnAgree.setVisibility(View.GONE);
        displayOnly = true;
    }
    mBinding.toolbar.setNavigationOnClickListener(new View.OnClickListener() {

        @Override
        public void onClick(View v) {
            onBackPressed();
        }
    });
    CharSequence titleChars = mBinding.toolbar.getTitle();
    SpannableStringBuilder sBuilder = new SpannableStringBuilder(titleChars);
    mBinding.toolbar.setTitle(sBuilder);
}

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.help);
    Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
    ViewCompat.setElevation(toolbar, getResources().getDimension(R.dimen.toolbar_elevation));
    setSupportActionBar(toolbar);
    ActionBar actionBar = getSupportActionBar();
    if (actionBar != null) {
        actionBar.setHomeButtonEnabled(true);
        actionBar.setDisplayHomeAsUpEnabled(true);
    }
    WebView browser = (WebView) findViewById(R.id.web_view);
    browser.loadUrl(getString(R.string.help_url));
    browser.setWebViewClient(new WebViewClient() {

        @SuppressWarnings("deprecation")
        public boolean shouldOverrideUrlLoading(WebView view, String url) {
            if (url != null && (url.startsWith("http://") || url.startsWith("https://"))) {
                view.getContext().startActivity(new Intent(Intent.ACTION_VIEW, Uri.parse(url)));
                return true;
            } else {
                return false;
            }
        }

        @TargetApi(Build.VERSION_CODES.N)
        @Override
        public boolean shouldOverrideUrlLoading(WebView view, WebResourceRequest request) {
            final String url = request.getUrl().toString();
            if (url != null && (url.startsWith("http://") || url.startsWith("https://"))) {
                view.getContext().startActivity(new Intent(Intent.ACTION_VIEW, Uri.parse(url)));
                return true;
            } else {
                return false;
            }
        }
    });
}

@Override
public WebResourceResponse shouldInterceptRequest(WebView view, WebResourceRequest request) {
    final String host = request.getUrl().getHost();
    // Allow URLs from Google for the TOS and Privacy Policy.
    if (host.matches("[a-z]*.google.com") || host.matches("[a-z]*.google.[a-z][a-z]") || host.matches("[a-z]*.google.co.[a-z][a-z]") || host.matches("[a-z]*.google.com.[a-z][a-z]") || host.matches("[a-z]*.gstatic.com") || host.equals("fonts.googleapis.com")) {
        return super.shouldInterceptRequest(view, request);
    }
    return new WebResourceResponse("", "", 403, "Denied", null, null);
}

public void init() {
    webView.setWebViewClient(new WebViewClient() {

        @Override
        public boolean shouldOverrideUrlLoading(WebView view, WebResourceRequest request) {
            view.loadUrl(request.toString());
            return true;
        }

        @Override
        public void onReceivedSslError(WebView view, SslErrorHandler handler, SslError error) {
            handler.proceed();
            if (callback != null) {
                callback.onError();
            }
        }

        @Override
        public void onReceivedError(WebView view, WebResourceRequest request, WebResourceError error) {
            super.onReceivedError(view, request, error);
            if (callback != null) {
                callback.onError();
            }
        }

        @Override
        public void onReceivedHttpError(WebView view, WebResourceRequest request, WebResourceResponse errorResponse) {
            super.onReceivedHttpError(view, request, errorResponse);
            if (callback != null)
                callback.onError();
        }

        @Override
        public void onPageStarted(WebView view, String url, Bitmap favicon) {
            super.onPageStarted(view, url, favicon);
            progressBar.setVisibility(VISIBLE);
        }

        @Override
        public void onPageFinished(WebView view, String url) {
            super.onPageFinished(view, url);
            subscribe.unsubscribe();
            progressBar.setProgress(100);
            progressBar.postDelayed(new Runnable() {

                @Override
                public void run() {
                    progressBar.setVisibility(INVISIBLE);
                    progressBar.setProgress(0);
                }
            }, 200);
        }
    });
    webView.setWebChromeClient(new WebChromeClient() {

        @Override
        public void onProgressChanged(WebView view, int newProgress) {
            super.onProgressChanged(view, newProgress);
            if (progressBar.getVisibility() == INVISIBLE)
                progressBar.setVisibility(VISIBLE);
            if (newProgress != 100) {
                progressBar.setProgress(newProgress);
            }
        }
    });
    //setting
    WebSettings settings = webView.getSettings();
    settings.setUseWideViewPort(true);
    settings.setAppCacheEnabled(true);
    settings.setDatabaseEnabled(true);
    settings.setDomStorageEnabled(true);
    settings.setCacheMode(WebSettings.LOAD_DEFAULT);
}

protected void initView() {
    /**
         * 测试用 非正式代码 ---By MummyDing
         */
    //对toolbar进行下移
    int height = DisplayUtil.getScreenHeight(LeisureApplication.AppContext);
    LinearLayout ll = (LinearLayout) findViewById(R.id.stbar);
    LinearLayout.LayoutParams llp = (LinearLayout.LayoutParams) ll.getLayoutParams();
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
        llp.height = (int) (height * 0.03);
        ll.setLayoutParams(llp);
    }
    mainContent = (FrameLayout) findViewById(R.id.main_content);
    scrollView = (NestedScrollView) findViewById(R.id.scrollView);
    progressBar = (ProgressBar) findViewById(R.id.progressBar);
    progressBarTopPic = (ProgressBar) findViewById(R.id.progressBarTopPic);
    networkBtn = (ImageButton) findViewById(R.id.networkBtn);
    topImage = (SimpleDraweeView) findViewById(R.id.topImage);
    toolbar = (Toolbar) findViewById(R.id.toolbar);
    setSupportActionBar(toolbar);
    getSupportActionBar().setDisplayHomeAsUpEnabled(true);
    getSupportActionBar().setTitle("");
    toolbar.setNavigationOnClickListener(new View.OnClickListener() {

        @Override
        public void onClick(View v) {
            onBackPressed();
        }
    });
    getSupportActionBar().setBackgroundDrawable(ContextCompat.getDrawable(this, R.drawable.top_gradient));
    contentView = (WebView) findViewById(R.id.content_view);
    contentView.getSettings().setJavaScriptEnabled(true);
    // 开启缓存
    contentView.getSettings().setCacheMode(WebSettings.LOAD_CACHE_ELSE_NETWORK);
    contentView.getSettings().setDomStorageEnabled(true);
    contentView.getSettings().setDatabaseEnabled(true);
    contentView.setWebViewClient(new WebViewClient() {

        @Override
        public void onPageFinished(WebView view, String url) {
            super.onPageFinished(view, url);
            hideLoading();
        }

        @Override
        public void onReceivedError(WebView view, WebResourceRequest request, WebResourceError error) {
            displayNetworkError();
        }

        @Override
        public boolean shouldOverrideUrlLoading(WebView view, String url) {
            contentView.loadUrl(url);
            return false;
        }
    });
    if (HttpUtil.isWIFI == false) {
        contentView.getSettings().setBlockNetworkImage(Settings.getInstance().getBoolean(Settings.NO_PIC_MODE, false));
    } else {
        // fix issue #13
        contentView.getSettings().setBlockNetworkImage(false);
    }
    /**
         * 网络异常就显示
         */
    networkBtn.setOnClickListener(new View.OnClickListener() {

        @Override
        public void onClick(View v) {
            networkBtn.setVisibility(View.GONE);
            progressBar.setVisibility(View.VISIBLE);
            onDataRefresh();
        }
    });
    onDataRefresh();
}

private void init() {
    setWebViewClient(new WebViewClient() {

        @Override
        public void onPageFinished(WebView view, String url) {
            loadUrl("javascript:document.body.style.margin=\"" + mPadding + "\"; void 0");
        }

        @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
        @Override
        public boolean shouldOverrideUrlLoading(WebView view, WebResourceRequest request) {
            getContext().startActivity(new Intent(Intent.ACTION_VIEW).setData(request.getUrl()).addFlags(Intent.FLAG_ACTIVITY_NEW_TASK));
            return true;
        }

        @Override
        public boolean shouldOverrideUrlLoading(WebView view, String url) {
            getContext().startActivity(new Intent(Intent.ACTION_VIEW).setData(Uri.parse(url)).addFlags(Intent.FLAG_ACTIVITY_NEW_TASK));
            return true;
        }
    });
}

@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
@Override
public WebResourceResponse shouldInterceptRequest(WebView view, WebResourceRequest request) {
    if (!SUPPORTED_SCHEMES.contains(request.getUrl().getScheme())) {
        return null;
    }
    try {
        Response rsp = request(request.getUrl().toString());
        return new WebResourceResponse(rsp.header(HEADER_CONTENT_TYPE), rsp.header(HEADER_CONTENT_ENCODING), rsp.code(), StringUtils.defaultIfBlank(rsp.message(), "Unknown error"), toMap(rsp.headers()), getInputStream(rsp));
    } catch (IOException e) {
        L.e(e);
    }
    return null;
}

private void initWebViewClient() {
    mWvShow.setWebViewClient(new WebViewClient() {

        @Override
        public void onPageStarted(WebView view, String url, Bitmap favicon) {
            super.onPageStarted(view, url, favicon);
        //                mPbShow.setVisibility(View.VISIBLE);
        }

        @Override
        public void onPageFinished(WebView view, String url) {
            super.onPageFinished(view, url);
        //                mPbShow.setVisibility(View.GONE);
        }

        @Override
        public boolean shouldOverrideUrlLoading(WebView view, WebResourceRequest request) {
            view.loadUrl(request.toString());
            return true;
        }

        @Override
        public void onReceivedError(WebView view, WebResourceRequest request, WebResourceError error) {
            super.onReceivedError(view, request, error);
        }
    });
}

@TargetApi(Build.VERSION_CODES.LOLLIPOP)
@Override
public WebResourceResponse shouldInterceptRequest(@NonNull WebView view, @NonNull WebResourceRequest request) {
    String url = request.getUrl().toString();
    if (url.contains("ads.js") || url.contains("f.js") || url.contains("pop.js") || url.contains("syndication.exoclick.com")) {
        return new WebResourceResponse("text/plain", "utf-8", nothing);
    } else if (url.contains("main.js")) {
        return getWebResourceResponseFromAsset(getSite(), "main.js", TYPE.JS);
    } else if (url.contains("exoclick.com") || url.contains("juicyadultads.com")) {
        return new WebResourceResponse("text/plain", "utf-8", nothing);
    } else {
        return super.shouldInterceptRequest(view, request);
    }
}

public WebViewClient getWebViewClient() {
    return new WebViewClient() {

        @Override
        public void onPageStarted(WebView view, String url, Bitmap favicon) {
            super.onPageStarted(view, url, favicon);
            LogUtils.d("startUrl:" + url);
            isError = false;
            webView.setVisibility(View.VISIBLE);
        }

        @Override
        public boolean shouldOverrideUrlLoading(WebView view, String url) {
            LogUtils.d("url:" + url);
            return super.shouldOverrideUrlLoading(view, url);
        }

        @Override
        public void onReceivedError(WebView view, WebResourceRequest request, WebResourceError error) {
            super.onReceivedError(view, request, error);
            updateProgressBar(100);
        }

        @Override
        public void onReceivedError(WebView view, int errorCode, String description, String failingUrl) {
            super.onReceivedError(view, errorCode, description, failingUrl);
            LogUtils.w("errorCode:" + errorCode + "|failingUrl:" + failingUrl);
            showReceiveError();
        }

        @Override
        public void onReceivedSslError(WebView view, SslErrorHandler handler, SslError error) {
            super.onReceivedSslError(view, handler, error);
            handler.cancel();
            handler.proceed();
        }

        @Override
        public void onPageFinished(WebView view, String url) {
            super.onPageFinished(view, url);
            hideReceiveError();
        }
    };
}

private void setWebView() {
    WebSettings settings = wvIt.getSettings();
    settings.setDomStorageEnabled(true);
    settings.setAppCacheEnabled(true);
    settings.setJavaScriptEnabled(true);
    settings.setCacheMode(WebSettings.LOAD_CACHE_ELSE_NETWORK);
    settings.setDomStorageEnabled(true);
    settings.setDatabaseEnabled(true);
    settings.setAppCachePath(getCacheDir().getAbsolutePath() + "/webViewCache");
    settings.setAppCacheEnabled(true);
    settings.setLoadWithOverviewMode(true);
    wvIt.setWebViewClient(new WebViewClient() {

        @TargetApi(Build.VERSION_CODES.N)
        @Override
        public boolean shouldOverrideUrlLoading(WebView view, WebResourceRequest request) {
            view.loadUrl(request.getUrl().getHost());
            return true;
        }

        @SuppressWarnings("deprecation")
        @Override
        public boolean shouldOverrideUrlLoading(WebView view, String url) {
            view.loadUrl(url);
            return true;
        }
    });
    wvIt.setWebChromeClient(new WebChromeClient() {

        @Override
        public void onProgressChanged(WebView view, int newProgress) {
            if (pbWeb != null) {
                //修复未加载完成，用户返回会崩溃
                if (newProgress == 100) {
                    pbWeb.setVisibility(View.GONE);
                } else {
                    if (pbWeb.getVisibility() == View.GONE) {
                        pbWeb.setVisibility(View.VISIBLE);
                    }
                    pbWeb.setProgress(newProgress);
                }
            }
            super.onProgressChanged(view, newProgress);
        }
    });
}

public void initJockey() {
    jockeyAsyncHandler = new JockeyAsyncHandler() {

        @Override
        protected void doPerform(Map<Object, Object> payload) {
            if (callback != null) {
                callback.doPerform(payload);
            }
        }
    };
    if (jockey == null) {
        jockey = JockeyImpl.getDefault();
    }
    jockey.configure(this);
    jockey.setWebViewClient(new WebViewClient() {

        @Override
        public boolean shouldOverrideUrlLoading(WebView view, String url) {
            try {
                if (!isJockeyScheme(new URI(url))) {
                    if (callback != null) {
                        callback.openBrowser(url);
                    }
                    return true;
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            return super.shouldOverrideUrlLoading(view, url);
        }

        @Override
        public void onPageStarted(WebView view, String url, Bitmap favicon) {
            super.onPageStarted(view, url, favicon);
            if (callback != null) {
                callback.onPageStarted(view, url, favicon);
            }
        }

        @Override
        public void onPageFinished(WebView view, String url) {
            super.onPageFinished(view, url);
            if (callback != null) {
                callback.onPageFinished(view, url);
            }
        }

        @Override
        public void onReceivedError(WebView view, WebResourceRequest request, WebResourceError error) {
            super.onReceivedError(view, request, error);
            if (callback != null) {
                callback.onReceivedError(view, request, error);
            }
        }
    });
    setJockeyEvents();
}

@Override
public void onReceivedError(WebView view1, WebResourceRequest request, WebResourceError error) {
    webView.setVisibility(View.GONE);
    imageView.setVisibility(View.VISIBLE);
    textView.setVisibility(View.VISIBLE);
    imageView.setOnClickListener(new View.OnClickListener() {

        @Override
        public void onClick(View view) {
            if (NetworkState.networkConnected(getContext())) {
                webView.loadUrl(url);
                webView.setVisibility(View.VISIBLE);
                imageView.setVisibility(View.GONE);
                textView.setVisibility(View.GONE);
            }
        }
    });
}

@Override
public boolean shouldOverrideUrlLoading(WebView view, WebResourceRequest request) {
    if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.LOLLIPOP) {
        Intent intent = new IntentsManager(getActivity()).checkUri(request.getUrl());
        if (intent != null) {
            startActivity(intent);
        } else {
            Intent intent1 = new Intent(Intent.ACTION_VIEW);
            intent1.setData(request.getUrl());
            startActivity(intent1);
        }
    }
    return true;
}

@Override
public void onReceivedError(WebView view, WebResourceRequest request, WebResourceError error) {
    super.onReceivedError(view, request, error);
    mIsLoading = false;
    if (LuaUtil.isTable(mLuaUserdata.getCallback())) {
        LuaUtil.callFunction(LuaUtil.getFunction(mLuaUserdata.getCallback(), "onReceivedError"), valueOf(error.getErrorCode()), valueOf(String.valueOf(error.getDescription())), valueOf(String.valueOf(request.getUrl())));
    }
    if (LVWebView.this.isRefreshing()) {
        LVWebView.this.setRefreshing(false);
    }
}

@Override
public void onViewCreated(View view, @Nullable Bundle savedInstanceState) {
    super.onViewCreated(view, savedInstanceState);
    mCodeContentLoader = new CodeFragmentContentLoader(view);
    setupToolbar();
    AppCompatActivity activity = (AppCompatActivity) getActivity();
    activity.setSupportActionBar(mToolbar);
    activity.getSupportActionBar().setDisplayHomeAsUpEnabled(true);
    activity.getSupportActionBar().setHomeAsUpIndicator(ContextCompat.getDrawable(getContext(), R.drawable.ic_view_list_white));
    mWebCodeRead.setScrollChangeListener(this);
    mWebCodeRead.getSettings().setJavaScriptEnabled(true);
    mWebCodeRead.getSettings().setSupportZoom(true);
    mWebCodeRead.getSettings().setBuiltInZoomControls(true);
    mWebCodeRead.setWebViewClient(new WebViewClient() {

        @Override
        public void onPageStarted(WebView view, String url, Bitmap favicon) {
            super.onPageStarted(view, url, favicon);
            mCodeContentLoader.showContent();
        }

        @Override
        public boolean shouldOverrideUrlLoading(WebView view, String url) {
            Navigator.startWebActivity(getContext(), url);
            return true;
        }

        @TargetApi(Build.VERSION_CODES.LOLLIPOP)
        @Override
        public boolean shouldOverrideUrlLoading(WebView view, WebResourceRequest request) {
            Navigator.startWebActivity(getContext(), String.valueOf(request.getUrl()));
            return true;
        }
    });
    mWebCodeRead.setWebChromeClient(new WebChromeClient() {
    });
    if (Build.VERSION.SDK_INT >= 11) {
        ((Runnable) () -> mWebCodeRead.getSettings().setDisplayZoomControls(false)).run();
    }
    openFile();
}

/**
     * Attempt to retrieve the WebResourceResponse associated with the given <code>request</code>.
     * This method should be invoked from within
     * {@link android.webkit.WebViewClient#shouldInterceptRequest(android.webkit.WebView,
     * android.webkit.WebResourceRequest)}.
     *
     * @param request the request to process.
     * @return a response if the request URL had a matching handler, null if no handler was found.
     */
public WebResourceResponse shouldInterceptRequest(WebResourceRequest request) {
    PathHandler handler;
    synchronized (uriMatcher) {
        handler = (PathHandler) uriMatcher.match(request.getUrl());
    }
    if (handler == null) {
        return null;
    }
    return new WebResourceResponse(handler.getMimeType(), handler.getEncoding(), handler.getStatusCode(), handler.getReasonPhrase(), handler.getResponseHeaders(), new LollipopLazyInputStream(handler, request));
}

/**
     * Notify the host application of a resource request and allow the application to return the
     * data. If the return value is null, the WebView will continue to load the resource as usual.
     * Otherwise, the return response and data will be used. NOTE: This method is called on a thread
     * other than the UI thread so clients should exercise caution when accessing private data or
     * the view system.
     *
     * @param view    The WebView that is requesting the resource.
     * @param request Object containing the details of the request.
     * @return A WebResourceResponse containing the response information or null if the WebView should load the resource itself.
     */
@Override
public WebResourceResponse shouldInterceptRequest(WebView view, WebResourceRequest request) {
    WebResourceResponse response = null;
    String method = request.getMethod();
    String url = request.getUrl().toString();
    try {
        if (!(url == null || url.isEmpty() || method == null || method.isEmpty())) {
            if (url.startsWith(context.getString(R.string.arp_url)) && method.equals("GET")) {
                // FILE MANAGEMENT (via Adaptive Packer)
                logger.log(ILoggingLogLevel.Debug, LOG_TAG, "Intercepting File request: " + request.getUrl().toString());
                AppResourceData resource = AppResourceManager.getInstance().retrieveWebResource(url);
                // Prepare the response
                response = new WebResourceResponse(resource.getRawType(), "UTF-8", 200, "OK", request.getRequestHeaders(), new ByteArrayInputStream(resource.getData()));
                return response;
            } else if (url.startsWith(context.getString(R.string.arp_url)) && method.equals("POST")) {
                // ADAPTIVE NATIVE CALLS
                APIRequest apiRequest = AppRegistryBridge.getJSONInstance().create().fromJson(request.getRequestHeaders().get("Content-Body"), APIRequest.class);
                logger.log(ILoggingLogLevel.Debug, LOG_TAG, "Intercepting ARP request: " + apiRequest);
                if (!apiRequest.getApiVersion().equals(AppRegistryBridge.getInstance().getAPIVersion())) {
                    logger.log(ILoggingLogLevel.Warn, LOG_TAG, "The API version of the Typescript API is not the same as the Platform API version");
                }
                // Call the service and return the data
                APIResponse apiResponse = ServiceHandler.getInstance().handleServiceUrl(apiRequest);
                // Prepare the response
                try {
                    response = new WebResourceResponse("application/javascript; charset=utf-8", "UTF-8", apiResponse.getStatusCode(), apiResponse.getStatusMessage(), request.getRequestHeaders(), new ByteArrayInputStream(AppRegistryBridge.getJSONInstance().create().toJson(apiResponse).getBytes("utf-8")));
                } catch (UnsupportedEncodingException e) {
                    logger.log(ILoggingLogLevel.Error, LOG_TAG, "shouldInterceptRequest Error:" + e.getLocalizedMessage());
                    return nonPermissionResponse(request);
                }
                return response;
            } else {
                if (Utils.validateUrl(url))
                    return null;
                else
                    return nonPermissionResponse(request);
            }
        } else {
            logger.log(ILoggingLogLevel.Error, LOG_TAG, "The method or the url is received is empty");
            return nonPermissionResponse(request);
        }
    } catch (Exception e) {
        logger.log(ILoggingLogLevel.Error, LOG_TAG, "shouldInterceptRequest Error:" + e.getLocalizedMessage());
        return nonPermissionResponse(request);
    }
}

@Override
public WebResourceResponse shouldInterceptRequest(WebView view, WebResourceRequest request) {
    String url = request.getUrl().toString();
    if (!url.startsWith("http") && !url.endsWith(md5File)) {
        String temp = url.substring("file://".length());
        String insideFileName;
        if (!temp.startsWith(extractPath)) {
            url = "file://" + extractPath + temp;
            insideFileName = temp;
        } else {
            insideFileName = temp.substring(extractPath.length());
        }
        if (insideFileName.contains("#")) {
            insideFileName = insideFileName.substring(0, insideFileName.indexOf("#"));
        }
        if (insideFileName.contains("?")) {
            insideFileName = insideFileName.substring(0, insideFileName.indexOf("?"));
        }
        if (insideFileName.contains("%20")) {
            insideFileName = insideFileName.replaceAll("%20", " ");
        }
        if (url.endsWith(".gif") || url.endsWith(".jpg") || url.endsWith(".png")) {
            try {
                return new WebResourceResponse("image/*", "", Utils.chm.getResourceAsStream(insideFileName));
            } catch (IOException e) {
                e.printStackTrace();
                return super.shouldInterceptRequest(view, request);
            }
        } else if (url.endsWith(".css") || url.endsWith(".js")) {
            try {
                return new WebResourceResponse("", "", Utils.chm.getResourceAsStream(insideFileName));
            } catch (IOException e) {
                e.printStackTrace();
                return super.shouldInterceptRequest(view, request);
            }
        } else {
            Utils.extractSpecificFile(chmFilePath, extractPath + insideFileName, insideFileName);
        }
    }
    Log.e("2, webviewrequest", url);
    return super.shouldInterceptRequest(view, request);
}

@Override
public WebResourceResponse shouldInterceptRequest(WebView view, WebResourceRequest request) {
    final Uri uri = request.getUrl();
    if (ContentResolver.SCHEME_FILE.equals(uri.getScheme()) && uri.getPath().endsWith(".gz")) {
        Log.d(TAG, "Trying to decompress " + uri + " on the fly");
        try {
            final InputStream in = new GZIPInputStream(getContentResolver().openInputStream(uri));
            final WebResourceResponse resp = new WebResourceResponse(getIntent().getType(), "utf-8", in);
            resp.setStatusCodeAndReasonPhrase(200, "OK");
            return resp;
        } catch (IOException e) {
            Log.w(TAG, "Failed to decompress; falling back", e);
        }
    }
    return null;
}

@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
    // Inflate the layout for this fragment
    View view = inflater.inflate(R.layout.fragment_webview, container, false);
    ButterKnife.bind(this, view);
    isSetProxy = false;
    urlText.setText(MainActivity.HOME_URL);
    WebSettings webSettings = webView.getSettings();
    webSettings.setJavaScriptEnabled(true);
    webSettings.setAllowFileAccess(true);
    webSettings.setDatabaseEnabled(true);
    String dir = getActivity().getApplicationContext().getDir("database", Context.MODE_PRIVATE).getPath();
    webSettings.setDatabasePath(dir);
    webSettings.setDomStorageEnabled(true);
    webSettings.setGeolocationEnabled(true);
    baseUserAgentString = webSettings.getUserAgentString() + " jdhttpmonitor/" + DeviceUtils.getVersion(getContext());
    webSettings.setUserAgentString(userAgentString);
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
        WebView.setWebContentsDebuggingEnabled(true);
    }
    webView.setDownloadListener(new MyWebViewDownLoadListener());
    webView.setWebViewClient(new WebViewClient() {

        //            @Override
        //            public boolean shouldOverrideUrlLoading(WebView view, WebResourceRequest request) {
        //                if(request.getUrl().toString().startsWith("jdhttpmonitor://webview")) {
        //                    Intent intent = new Intent("android.intent.action.VIEW");
        //                    intent.setData(Uri.parse(request.getUrl().toString()));
        //                    startActivity(intent);
        //                    return true;
        //                }
        //                return false;
        //            }
        @Override
        public boolean shouldOverrideUrlLoading(WebView view, String url) {
            if (url.startsWith("jdhttpmonitor://webview")) {
                Intent intent = new Intent("android.intent.action.VIEW");
                intent.setData(Uri.parse(url));
                startActivity(intent);
                return true;
            }
            return false;
        }

        @Override
        public void onPageFinished(WebView view, String url) {
            super.onPageFinished(view, url);
        }

        @Override
        public void onPageStarted(WebView view, String url, Bitmap favicon) {
            super.onPageStarted(view, url, favicon);
            urlText.setText(url);
        }
    });
    webView.setWebChromeClient(new WebChromeClient() {

        //            @Override
        //            public void onConsoleMessage(String message, int lineNumber, String sourceID) {
        //                super.onConsoleMessage(message, lineNumber, sourceID);
        //                ((MainActivity)getActivity()).consoleLog.append(message).append("\n").append("\n");
        //            }
        @Override
        public boolean onConsoleMessage(ConsoleMessage consoleMessage) {
            ((MainActivity) getActivity()).consoleLog.append(consoleMessage.message()).append("\n").append("\n");
            return super.onConsoleMessage(consoleMessage);
        }

        public void onProgressChanged(WebView view, int progress) {
            progressBar.setProgress(progress);
            if (progress == 100) {
                progressBar.setVisibility(View.GONE);
                swipeRefreshLayout.setRefreshing(false);
            } else {
                progressBar.setVisibility(View.VISIBLE);
            }
        }
    });
    jumpButton.setOnClickListener(new View.OnClickListener() {

        @Override
        public void onClick(View view) {
            if (urlText.getText().length() > 0) {
                loadUrl(urlText.getText() + "");
            }
        }
    });
    urlText.setImeOptions(EditorInfo.IME_ACTION_GO);
    urlText.setOnEditorActionListener(new TextView.OnEditorActionListener() {

        @Override
        public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
            //注意，这是一定要判断event != null。因为在某些输入法上会返回null。
            if (actionId == EditorInfo.IME_ACTION_GO || actionId == EditorInfo.IME_ACTION_DONE || (event != null && KeyEvent.KEYCODE_ENTER == event.getKeyCode() && KeyEvent.ACTION_DOWN == event.getAction())) {
                if (urlText.getText().length() > 0) {
                    loadUrl(v.getText() + "");
                    InputMethodManager imm = (InputMethodManager) getActivity().getSystemService(Context.INPUT_METHOD_SERVICE);
                    if (imm != null) {
                        imm.hideSoftInputFromWindow(v.getWindowToken(), 0);
                    }
                }
            //处理事件
            }
            return false;
        }
    });
    swipeRefreshLayout.setColorSchemeResources(R.color.colorAccentDark, R.color.colorAccent);
    swipeRefreshLayout.setOnRefreshListener(new SwipeRefreshLayout.OnRefreshListener() {

        @Override
        public void onRefresh() {
            //重新刷新页面
            webView.loadUrl(webView.getUrl());
        }
    });
    initProxyWebView();
    return view;
}

@TargetApi(Build.VERSION_CODES.LOLLIPOP)
@Override
public WebResourceResponse shouldInterceptRequest(WebView view, WebResourceRequest request) {
    String url = request.getUrl().toString();
    if (!URLUtil.isNetworkUrl(url)) {
        return super.shouldInterceptRequest(view, request);
    }
    // Request and add an authorization header for HTTPS resource requests.
    // Use https:// when requesting the auth header, in case the resource is incorrectly using http://.
    // If an auth header is returned, force https:// for the actual HTTP request.
    String authHeader = mAuthHeaderRequestListener.onAuthHeaderRequested(UrlUtils.makeHttps(url));
    if (StringUtils.notNullStr(authHeader).length() > 0) {
        try {
            url = UrlUtils.makeHttps(url);
            // Keep any existing request headers from the WebResourceRequest
            Map<String, String> headerMap = request.getRequestHeaders();
            for (Map.Entry<String, String> entry : mHeaderMap.entrySet()) {
                headerMap.put(entry.getKey(), entry.getValue());
            }
            headerMap.put("Authorization", authHeader);
            HttpURLConnection conn = HTTPUtils.setupUrlConnection(url, headerMap);
            return new WebResourceResponse(conn.getContentType(), conn.getContentEncoding(), conn.getInputStream());
        } catch (IOException e) {
            AppLog.e(T.EDITOR, e);
        }
    }
    return super.shouldInterceptRequest(view, request);
}

@Override
public WebResourceResponse shouldInterceptRequest(WebView view, WebResourceRequest request) {
    String url = request.getUrl().toString().toLowerCase();
    LogUtils.d("req -- " + url);
    if (!ADFilterUtils.hasAd(getContext(), url)) {
        return super.shouldInterceptRequest(view, request);
    } else {
        LogUtils.w("ad:" + url);
        return new WebResourceResponse(null, null, null);
    }
}

@Override
@TargetApi(Build.VERSION_CODES.M)
public void onReceivedHttpError(WebView view, WebResourceRequest request, WebResourceResponse errorResponse) {
    didReceiveError = true;
    switch(errorResponse.getStatusCode()) {
        case HttpStatus.FORBIDDEN:
        case HttpStatus.UNAUTHORIZED:
        case HttpStatus.NOT_FOUND:
            EdxCookieManager.getSharedInstance().tryToRefreshSessionCookie();
            break;
    }
    showErrorMessage(R.string.network_error_message, FontAwesomeIcons.fa_exclamation_circle);
}

@TargetApi(Build.VERSION_CODES.M)
@Override
public void onReceivedError(WebView view, WebResourceRequest request, WebResourceError webResourceError) {
    String errMsg = "WebViewError:";
    if (webResourceError != null) {
        if (webResourceError.getErrorCode() == -2) {
        //view.loadData("<div></div>", "text/html", "UTF-8");
        }
        errMsg += webResourceError.getErrorCode() + "-";
        errMsg += webResourceError.getDescription() + "-";
        if (request != null && request.getUrl() != null) {
            errMsg += request.getUrl().toString();
        }
    }
    if (errMsg.contains("favicon.ico")) {
        return;
    }
    controlsViewClient.handleKControlsError(new KPError(errMsg));
}

// ///////////////////////////////////////////////////////////////////////////
// LIFECYCLE
// ///////////////////////////////////////////////////////////////////////////
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
    if (container == null) {
        return null;
    }
    EventBusManager.getInstance().register(this);
    if (getArguments() != null) {
        layout_id = BundleUtils.getInt(getArguments(), LAYOUT_ID);
        if (getArguments().containsKey(ARGUMENT_BASE_URL)) {
            urlInfo = (URLInfo) BundleUtils.getSerializable(getArguments(), ARGUMENT_BASE_URL);
        }
        if (getArguments().containsKey(ARGUMENT_ACCOUNT)) {
            account = (AlfrescoAccount) BundleUtils.getSerializable(getArguments(), ARGUMENT_ACCOUNT);
            NotificationManager.getInstance(getActivity()).showInfoCrouton(getActivity(), R.string.error_session_expired);
        }
        if (urlInfo != null) {
            helper = new Saml2AuthHelper(urlInfo.baseUrl);
        } else if (account != null) {
            helper = new Saml2AuthHelper(account.getUrl());
        }
    }
    View v = inflater.inflate(layout_id, container, false);
    webview = (WebView) v.findViewById(org.alfresco.mobile.android.foundation.R.id.webview);
    webview.clearCache(true);
    webview.getSettings().setJavaScriptEnabled(true);
    webview.getSettings().setBuiltInZoomControls(true);
    // webview.getSettings().setUseWideViewPort(true);
    final View waiting = v.findViewById(R.id.waiting);
    if (AndroidVersion.isLollipopOrAbove()) {
        webview.getSettings().setMixedContentMode(WebSettings.MIXED_CONTENT_ALWAYS_ALLOW);
    }
    webview.setWebChromeClient(new WebChromeClient() {

        public boolean onConsoleMessage(ConsoleMessage cmsg) {
            String message = cmsg.message().trim();
            if (checkAuthResponseURLResponse(lastUrl)) {
                if (message.startsWith("{")) {
                    Map<String, Object> json = JsonUtils.parseObject(message);
                    SamlData data = new SamlDataImpl(null, urlInfo != null ? urlInfo.samlData : null);
                    ((SamlDataImpl) data).setSamlTicket(json);
                    load(data);
                }
            }
            return true;
        }
    });
    webview.setWebViewClient(new WebViewClient() {

        @Override
        public void onReceivedHttpError(WebView view, WebResourceRequest request, WebResourceResponse errorResponse) {
            Log.d("SAML", "onReceivedHttpError: " + lastUrl);
            super.onReceivedHttpError(view, request, errorResponse);
        }

        @Override
        public void onReceivedError(WebView view, WebResourceRequest request, WebResourceError error) {
            Log.d("SAML", "onReceivedError: " + lastUrl);
            super.onReceivedError(view, request, error);
            if (checkAuthResponseURLResponse(lastUrl)) {
                view.loadUrl(helper.getAuthenticateUrl());
                return;
            }
        }

        @Override
        public void onPageFinished(WebView view, String url) {
            lastUrl = url;
            if (url.endsWith(SAMLConstant.SMALV2_RESTAPI_AUTHENTICATE_PATH)) {
                waiting.setVisibility(View.GONE);
                view.setVisibility(View.VISIBLE);
                super.onPageFinished(view, url);
            } else if (checkAuthResponseURLResponse(url)) {
                view.setVisibility(View.GONE);
                waiting.setVisibility(View.VISIBLE);
                Log.d("SAML", "onPageFinished: Get Info - " + url);
                view.loadUrl("javascript:console.log(document.body.getElementsByTagName('pre')[0].innerHTML);");
            } else {
                waiting.setVisibility(View.GONE);
                view.setVisibility(View.VISIBLE);
                super.onPageFinished(view, url);
            }
            if (getActivity() != null) {
                if (getActivity() instanceof AlfrescoActivity) {
                    ((AlfrescoActivity) getActivity()).removeWaitingDialog();
                } else if (getActivity() instanceof AlfrescoAppCompatActivity) {
                    ((AlfrescoAppCompatActivity) getActivity()).removeWaitingDialog();
                }
            }
        }
    });
    webview.loadUrl(helper.getAuthenticateUrl());
    return v;
}

@Override
public void onReceivedError(WebView view, WebResourceRequest request, WebResourceError error) {
    super.onReceivedError(view, request, error);
    if (mOnErrorListener != null) {
        //mOnErrorListener.onError("error", "page error code:" + error.getErrorCode() + ", desc:" + error.getDescription() + ", url:" + request.getUrl());
        mOnErrorListener.onError("error", "page error");
    }
}

@SuppressLint("SetJavaScriptEnabled")
@Override
protected void onPostExecute(File result) {
    Log.v(TAG, "loadHTMLFile:onPostExecute, result=" + result);
    if (isFinishing()) {
        Log.v(TAG, "finishing, ignoring loadHTMLFile result");
        return;
    }
    WebView webView = mWebView;
    if (webView == null) {
        Log.v(TAG, "Must be destroyed or destroying, we have no webview, ignoring loadHTMLFile result");
        return;
    }
    if (result == null) {
        Snackbar.make(webView, R.string.error_reading_log, Snackbar.LENGTH_LONG).show();
        return;
    }
    // Load the exported HTML file into the WebView.
    // Save our current horizontal scroll position so we can keep our
    // horizontal position after reloading the page.
    final int oldScrollX = webView.getScrollX();
    webView.getSettings().setUseWideViewPort(true);
    webView.getSettings().setBuiltInZoomControls(true);
    webView.getSettings().setJavaScriptEnabled(true);
    webView.loadUrl("file://" + result.getAbsolutePath());
    webView.setWebViewClient(new WebViewClient() {

        @Override
        public void onPageStarted(WebView view, String url, Bitmap favicon) {
            super.onPageStarted(view, url, favicon);
            Log.v(TAG, "onPageStarted");
            // http://stackoverflow.com/questions/6855715/maintain-webview-content-scroll-position-on-orientation-change
            if (oldScrollX > 0) {
                String jsScrollX = "javascript:window:scrollTo(" + oldScrollX + " / window.devicePixelRatio,0);";
                view.loadUrl(jsScrollX);
            }
        }

        @Override
        public void onPageFinished(WebView view, String url) {
            super.onPageFinished(view, url);
            progressBar.setVisibility(View.GONE);
            stopRefreshIconAnimation();
        }

        @Override
        @TargetApi(Build.VERSION_CODES.N)
        public boolean shouldOverrideUrlLoading(WebView view, WebResourceRequest request) {
            return loadUrl(request.getUrl().toString()) || super.shouldOverrideUrlLoading(view, request);
        }

        @SuppressWarnings("deprecation")
        @Override
        public boolean shouldOverrideUrlLoading(WebView view, String url) {
            return loadUrl(url) || super.shouldOverrideUrlLoading(view, url);
        }

        private boolean loadUrl(String url) {
            Log.v(TAG, "url: " + url);
            // the sorting preference (column name, ascending or descending order).
            if (url.startsWith(HTMLExport.URL_SORT)) {
                NetMonPreferences prefs = NetMonPreferences.getInstance(LogActivity.this);
                SortPreferences oldSortPreferences = prefs.getSortPreferences();
                // The new column used for sorting will be the one the user tapped on.
                String newSortColumnName = url.substring(HTMLExport.URL_SORT.length());
                SortOrder newSortOrder = oldSortPreferences.sortOrder;
                // toggle the sort order between ascending and descending.
                if (newSortColumnName.equals(oldSortPreferences.sortColumnName)) {
                    if (oldSortPreferences.sortOrder == SortOrder.DESC)
                        newSortOrder = SortOrder.ASC;
                    else
                        newSortOrder = SortOrder.DESC;
                }
                // Update the sorting preferences (our shared preference change listener will be notified
                // and reload the page).
                prefs.setSortPreferences(new SortPreferences(newSortColumnName, newSortOrder));
                return true;
            } else // If the user clicked on the filter icon, start the filter activity for this column.
            if (url.startsWith(HTMLExport.URL_FILTER)) {
                Intent intent = new Intent(LogActivity.this, FilterColumnActivity.class);
                String columnName = url.substring(HTMLExport.URL_FILTER.length());
                intent.putExtra(FilterColumnActivity.EXTRA_COLUMN_NAME, columnName);
                startActivityForResult(intent, REQUEST_CODE_FILTER_COLUMN);
                return true;
            } else {
                return false;
            }
        }
    });
}

@Override
public WebResourceResponse shouldInterceptRequest(WebView view, WebResourceRequest resourceRequest) {
    // That call is for the API level is higher or equal to 21
    String currentUrl = resourceRequest.getUrl().toString();
    // protection are not enabled.
    if (!mTrackingProtectionEnabled && !mAdblockEnabled && !mHttpsEverywhereEnabled || mUrl.toString().equals(currentUrl)) {
        return null;
    }
    String filterOption = "none";
    Map<String, String> requestHeaders = resourceRequest.getRequestHeaders();
    for (Map.Entry<String, String> entry : requestHeaders.entrySet()) {
        if (entry.getKey().equals("Accept")) {
            if (entry.getValue().contains("/css")) {
                filterOption = "/css";
                break;
            } else if (entry.getValue().contains("image/")) {
                filterOption = "image/";
                break;
            } else if (entry.getValue().contains("javascript")) {
                filterOption = "javascript";
                break;
            }
        }
    }
    return interceptTheCall(view, currentUrl, filterOption, true);
}

@SuppressLint({ "SetJavaScriptEnabled" })
protected void init(Context context) {
    // in IDE's preview mode
    if (isInEditMode()) {
        // do not run the code from this method
        return;
    }
    if (context instanceof Activity) {
        mActivity = new WeakReference<Activity>((Activity) context);
    }
    mLanguageIso3 = getLanguageIso3();
    setFocusable(true);
    setFocusableInTouchMode(true);
    setSaveEnabled(true);
    final String filesDir = context.getFilesDir().getPath();
    final String databaseDir = filesDir.substring(0, filesDir.lastIndexOf("/")) + DATABASES_SUB_FOLDER;
    final WebSettings webSettings = getSettings();
    webSettings.setAllowFileAccess(false);
    setAllowAccessFromFileUrls(webSettings, false);
    webSettings.setBuiltInZoomControls(false);
    webSettings.setJavaScriptEnabled(true);
    webSettings.setDomStorageEnabled(true);
    if (Build.VERSION.SDK_INT < 18) {
        webSettings.setRenderPriority(WebSettings.RenderPriority.HIGH);
    }
    webSettings.setDatabaseEnabled(true);
    if (Build.VERSION.SDK_INT < 19) {
        webSettings.setDatabasePath(databaseDir);
    }
    setMixedContentAllowed(webSettings, true);
    setThirdPartyCookiesEnabled(true);
    super.setWebViewClient(new WebViewClient() {

        @Override
        public void onPageStarted(WebView view, String url, Bitmap favicon) {
            if (!hasError()) {
                if (mListener != null) {
                    mListener.onPageStarted(url, favicon);
                }
            }
            if (mCustomWebViewClient != null) {
                mCustomWebViewClient.onPageStarted(view, url, favicon);
            }
        }

        @Override
        public void onPageFinished(WebView view, String url) {
            if (!hasError()) {
                if (mListener != null) {
                    mListener.onPageFinished(url);
                }
            }
            if (mCustomWebViewClient != null) {
                mCustomWebViewClient.onPageFinished(view, url);
            }
        }

        @Override
        public void onReceivedError(WebView view, int errorCode, String description, String failingUrl) {
            setLastError();
            if (mListener != null) {
                mListener.onPageError(errorCode, description, failingUrl);
            }
            if (mCustomWebViewClient != null) {
                mCustomWebViewClient.onReceivedError(view, errorCode, description, failingUrl);
            }
        }

        @Override
        public boolean shouldOverrideUrlLoading(final WebView view, final String url) {
            // if the hostname may not be accessed
            if (!isHostnameAllowed(url)) {
                // if a listener is available
                if (mListener != null) {
                    // inform the listener about the request
                    mListener.onExternalPageRequest(url);
                }
                // cancel the original request
                return true;
            }
            // if there is a user-specified handler available
            if (mCustomWebViewClient != null) {
                // if the user-specified handler asks to override the request
                if (mCustomWebViewClient.shouldOverrideUrlLoading(view, url)) {
                    // cancel the original request
                    return true;
                }
            }
            // route the request through the custom URL loading method
            view.loadUrl(url);
            // cancel the original request
            return true;
        }

        @Override
        public void onLoadResource(WebView view, String url) {
            if (mCustomWebViewClient != null) {
                mCustomWebViewClient.onLoadResource(view, url);
            } else {
                super.onLoadResource(view, url);
            }
        }

        @SuppressLint("NewApi")
        @SuppressWarnings("all")
        public WebResourceResponse shouldInterceptRequest(WebView view, String url) {
            if (Build.VERSION.SDK_INT >= 11) {
                if (mCustomWebViewClient != null) {
                    return mCustomWebViewClient.shouldInterceptRequest(view, url);
                } else {
                    return super.shouldInterceptRequest(view, url);
                }
            } else {
                return null;
            }
        }

        @SuppressLint("NewApi")
        @SuppressWarnings("all")
        public WebResourceResponse shouldInterceptRequest(WebView view, WebResourceRequest request) {
            if (Build.VERSION.SDK_INT >= 21) {
                if (mCustomWebViewClient != null) {
                    return mCustomWebViewClient.shouldInterceptRequest(view, request);
                } else {
                    return super.shouldInterceptRequest(view, request);
                }
            } else {
                return null;
            }
        }

        @Override
        public void onFormResubmission(WebView view, Message dontResend, Message resend) {
            if (mCustomWebViewClient != null) {
                mCustomWebViewClient.onFormResubmission(view, dontResend, resend);
            } else {
                super.onFormResubmission(view, dontResend, resend);
            }
        }

        @Override
        public void doUpdateVisitedHistory(WebView view, String url, boolean isReload) {
            if (mCustomWebViewClient != null) {
                mCustomWebViewClient.doUpdateVisitedHistory(view, url, isReload);
            } else {
                super.doUpdateVisitedHistory(view, url, isReload);
            }
        }

        @Override
        public void onReceivedSslError(WebView view, SslErrorHandler handler, SslError error) {
            if (mCustomWebViewClient != null) {
                mCustomWebViewClient.onReceivedSslError(view, handler, error);
            } else {
                super.onReceivedSslError(view, handler, error);
            }
        }

        @SuppressLint("NewApi")
        @SuppressWarnings("all")
        public void onReceivedClientCertRequest(WebView view, ClientCertRequest request) {
            if (Build.VERSION.SDK_INT >= 21) {
                if (mCustomWebViewClient != null) {
                    mCustomWebViewClient.onReceivedClientCertRequest(view, request);
                } else {
                    super.onReceivedClientCertRequest(view, request);
                }
            }
        }

        @Override
        public void onReceivedHttpAuthRequest(WebView view, HttpAuthHandler handler, String host, String realm) {
            if (mCustomWebViewClient != null) {
                mCustomWebViewClient.onReceivedHttpAuthRequest(view, handler, host, realm);
            } else {
                super.onReceivedHttpAuthRequest(view, handler, host, realm);
            }
        }

        @Override
        public boolean shouldOverrideKeyEvent(WebView view, KeyEvent event) {
            if (mCustomWebViewClient != null) {
                return mCustomWebViewClient.shouldOverrideKeyEvent(view, event);
            } else {
                return super.shouldOverrideKeyEvent(view, event);
            }
        }

        @Override
        public void onUnhandledKeyEvent(WebView view, KeyEvent event) {
            if (mCustomWebViewClient != null) {
                mCustomWebViewClient.onUnhandledKeyEvent(view, event);
            } else {
                super.onUnhandledKeyEvent(view, event);
            }
        }

        @SuppressLint("NewApi")
        @SuppressWarnings("all")
        public void onUnhandledInputEvent(WebView view, InputEvent event) {
            if (Build.VERSION.SDK_INT >= 21) {
                if (mCustomWebViewClient != null) {
                    mCustomWebViewClient.onUnhandledInputEvent(view, event);
                } else {
                    super.onUnhandledInputEvent(view, event);
                }
            }
        }

        @Override
        public void onScaleChanged(WebView view, float oldScale, float newScale) {
            if (mCustomWebViewClient != null) {
                mCustomWebViewClient.onScaleChanged(view, oldScale, newScale);
            } else {
                super.onScaleChanged(view, oldScale, newScale);
            }
        }

        @SuppressLint("NewApi")
        @SuppressWarnings("all")
        public void onReceivedLoginRequest(WebView view, String realm, String account, String args) {
            if (Build.VERSION.SDK_INT >= 12) {
                if (mCustomWebViewClient != null) {
                    mCustomWebViewClient.onReceivedLoginRequest(view, realm, account, args);
                } else {
                    super.onReceivedLoginRequest(view, realm, account, args);
                }
            }
        }
    });
    super.setWebChromeClient(new WebChromeClient() {

        // file upload callback (Android 2.2 (API level 8) -- Android 2.3 (API level 10)) (hidden method)
        @SuppressWarnings("unused")
        public void openFileChooser(ValueCallback<Uri> uploadMsg) {
            openFileChooser(uploadMsg, null);
        }

        // file upload callback (Android 3.0 (API level 11) -- Android 4.0 (API level 15)) (hidden method)
        public void openFileChooser(ValueCallback<Uri> uploadMsg, String acceptType) {
            openFileChooser(uploadMsg, acceptType, null);
        }

        // file upload callback (Android 4.1 (API level 16) -- Android 4.3 (API level 18)) (hidden method)
        @SuppressWarnings("unused")
        public void openFileChooser(ValueCallback<Uri> uploadMsg, String acceptType, String capture) {
            openFileInput(uploadMsg, null, false);
        }

        // file upload callback (Android 5.0 (API level 21) -- current) (public method)
        @SuppressWarnings("all")
        public boolean onShowFileChooser(WebView webView, ValueCallback<Uri[]> filePathCallback, WebChromeClient.FileChooserParams fileChooserParams) {
            if (Build.VERSION.SDK_INT >= 21) {
                final boolean allowMultiple = fileChooserParams.getMode() == FileChooserParams.MODE_OPEN_MULTIPLE;
                openFileInput(null, filePathCallback, allowMultiple);
                return true;
            } else {
                return false;
            }
        }

        @Override
        public void onProgressChanged(WebView view, int newProgress) {
            if (mCustomWebChromeClient != null) {
                mCustomWebChromeClient.onProgressChanged(view, newProgress);
            } else {
                super.onProgressChanged(view, newProgress);
            }
        }

        @Override
        public void onReceivedTitle(WebView view, String title) {
            if (mCustomWebChromeClient != null) {
                mCustomWebChromeClient.onReceivedTitle(view, title);
            } else {
                super.onReceivedTitle(view, title);
            }
        }

        @Override
        public void onReceivedIcon(WebView view, Bitmap icon) {
            if (mCustomWebChromeClient != null) {
                mCustomWebChromeClient.onReceivedIcon(view, icon);
            } else {
                super.onReceivedIcon(view, icon);
            }
        }

        @Override
        public void onReceivedTouchIconUrl(WebView view, String url, boolean precomposed) {
            if (mCustomWebChromeClient != null) {
                mCustomWebChromeClient.onReceivedTouchIconUrl(view, url, precomposed);
            } else {
                super.onReceivedTouchIconUrl(view, url, precomposed);
            }
        }

        @Override
        public void onShowCustomView(View view, CustomViewCallback callback) {
            if (mCustomWebChromeClient != null) {
                mCustomWebChromeClient.onShowCustomView(view, callback);
            } else {
                super.onShowCustomView(view, callback);
            }
        }

        @SuppressLint("NewApi")
        @SuppressWarnings("all")
        public void onShowCustomView(View view, int requestedOrientation, CustomViewCallback callback) {
            if (Build.VERSION.SDK_INT >= 14) {
                if (mCustomWebChromeClient != null) {
                    mCustomWebChromeClient.onShowCustomView(view, requestedOrientation, callback);
                } else {
                    super.onShowCustomView(view, requestedOrientation, callback);
                }
            }
        }

        @Override
        public void onHideCustomView() {
            if (mCustomWebChromeClient != null) {
                mCustomWebChromeClient.onHideCustomView();
            } else {
                super.onHideCustomView();
            }
        }

        @Override
        public boolean onCreateWindow(WebView view, boolean isDialog, boolean isUserGesture, Message resultMsg) {
            if (mCustomWebChromeClient != null) {
                return mCustomWebChromeClient.onCreateWindow(view, isDialog, isUserGesture, resultMsg);
            } else {
                return super.onCreateWindow(view, isDialog, isUserGesture, resultMsg);
            }
        }

        @Override
        public void onRequestFocus(WebView view) {
            if (mCustomWebChromeClient != null) {
                mCustomWebChromeClient.onRequestFocus(view);
            } else {
                super.onRequestFocus(view);
            }
        }

        @Override
        public void onCloseWindow(WebView window) {
            if (mCustomWebChromeClient != null) {
                mCustomWebChromeClient.onCloseWindow(window);
            } else {
                super.onCloseWindow(window);
            }
        }

        @Override
        public boolean onJsAlert(WebView view, String url, String message, JsResult result) {
            if (mCustomWebChromeClient != null) {
                return mCustomWebChromeClient.onJsAlert(view, url, message, result);
            } else {
                return super.onJsAlert(view, url, message, result);
            }
        }

        @Override
        public boolean onJsConfirm(WebView view, String url, String message, JsResult result) {
            if (mCustomWebChromeClient != null) {
                return mCustomWebChromeClient.onJsConfirm(view, url, message, result);
            } else {
                return super.onJsConfirm(view, url, message, result);
            }
        }

        @Override
        public boolean onJsPrompt(WebView view, String url, String message, String defaultValue, JsPromptResult result) {
            if (mCustomWebChromeClient != null) {
                return mCustomWebChromeClient.onJsPrompt(view, url, message, defaultValue, result);
            } else {
                return super.onJsPrompt(view, url, message, defaultValue, result);
            }
        }

        @Override
        public boolean onJsBeforeUnload(WebView view, String url, String message, JsResult result) {
            if (mCustomWebChromeClient != null) {
                return mCustomWebChromeClient.onJsBeforeUnload(view, url, message, result);
            } else {
                return super.onJsBeforeUnload(view, url, message, result);
            }
        }

        @Override
        public void onGeolocationPermissionsShowPrompt(String origin, Callback callback) {
            if (mGeolocationEnabled) {
                callback.invoke(origin, true, false);
            } else {
                if (mCustomWebChromeClient != null) {
                    mCustomWebChromeClient.onGeolocationPermissionsShowPrompt(origin, callback);
                } else {
                    super.onGeolocationPermissionsShowPrompt(origin, callback);
                }
            }
        }

        @Override
        public void onGeolocationPermissionsHidePrompt() {
            if (mCustomWebChromeClient != null) {
                mCustomWebChromeClient.onGeolocationPermissionsHidePrompt();
            } else {
                super.onGeolocationPermissionsHidePrompt();
            }
        }

        @SuppressLint("NewApi")
        @SuppressWarnings("all")
        public void onPermissionRequest(PermissionRequest request) {
            if (Build.VERSION.SDK_INT >= 21) {
                if (mCustomWebChromeClient != null) {
                    mCustomWebChromeClient.onPermissionRequest(request);
                } else {
                    super.onPermissionRequest(request);
                }
            }
        }

        @SuppressLint("NewApi")
        @SuppressWarnings("all")
        public void onPermissionRequestCanceled(PermissionRequest request) {
            if (Build.VERSION.SDK_INT >= 21) {
                if (mCustomWebChromeClient != null) {
                    mCustomWebChromeClient.onPermissionRequestCanceled(request);
                } else {
                    super.onPermissionRequestCanceled(request);
                }
            }
        }

        @Override
        public boolean onJsTimeout() {
            if (mCustomWebChromeClient != null) {
                return mCustomWebChromeClient.onJsTimeout();
            } else {
                return super.onJsTimeout();
            }
        }

        @Override
        public void onConsoleMessage(String message, int lineNumber, String sourceID) {
            if (mCustomWebChromeClient != null) {
                mCustomWebChromeClient.onConsoleMessage(message, lineNumber, sourceID);
            } else {
                super.onConsoleMessage(message, lineNumber, sourceID);
            }
        }

        @Override
        public boolean onConsoleMessage(ConsoleMessage consoleMessage) {
            if (mCustomWebChromeClient != null) {
                return mCustomWebChromeClient.onConsoleMessage(consoleMessage);
            } else {
                return super.onConsoleMessage(consoleMessage);
            }
        }

        @Override
        public Bitmap getDefaultVideoPoster() {
            if (mCustomWebChromeClient != null) {
                return mCustomWebChromeClient.getDefaultVideoPoster();
            } else {
                return super.getDefaultVideoPoster();
            }
        }

        @Override
        public View getVideoLoadingProgressView() {
            if (mCustomWebChromeClient != null) {
                return mCustomWebChromeClient.getVideoLoadingProgressView();
            } else {
                return super.getVideoLoadingProgressView();
            }
        }

        @Override
        public void getVisitedHistory(ValueCallback<String[]> callback) {
            if (mCustomWebChromeClient != null) {
                mCustomWebChromeClient.getVisitedHistory(callback);
            } else {
                super.getVisitedHistory(callback);
            }
        }

        @Override
        public void onExceededDatabaseQuota(String url, String databaseIdentifier, long quota, long estimatedDatabaseSize, long totalQuota, QuotaUpdater quotaUpdater) {
            if (mCustomWebChromeClient != null) {
                mCustomWebChromeClient.onExceededDatabaseQuota(url, databaseIdentifier, quota, estimatedDatabaseSize, totalQuota, quotaUpdater);
            } else {
                super.onExceededDatabaseQuota(url, databaseIdentifier, quota, estimatedDatabaseSize, totalQuota, quotaUpdater);
            }
        }

        @Override
        public void onReachedMaxAppCacheSize(long requiredStorage, long quota, QuotaUpdater quotaUpdater) {
            if (mCustomWebChromeClient != null) {
                mCustomWebChromeClient.onReachedMaxAppCacheSize(requiredStorage, quota, quotaUpdater);
            } else {
                super.onReachedMaxAppCacheSize(requiredStorage, quota, quotaUpdater);
            }
        }
    });
    setDownloadListener(new DownloadListener() {

        @Override
        public void onDownloadStart(final String url, final String userAgent, final String contentDisposition, final String mimeType, final long contentLength) {
            final String suggestedFilename = URLUtil.guessFileName(url, contentDisposition, mimeType);
            if (mListener != null) {
                mListener.onDownloadRequested(url, suggestedFilename, mimeType, contentLength, contentDisposition, userAgent);
            }
        }
    });
}

@Override
public void onReceivedError(WebView view, WebResourceRequest request, WebResourceError error) {
    super.onReceivedError(view, request, error);
    view.loadDataWithBaseURL("", showErrorString, "text/html", "utf-8", null);
}

@Override
public WebResourceResponse shouldInterceptRequest(WebView view, WebResourceRequest request) {
    StopWatch.log("shouldInterceptRequest_new: " + request);
    return super.shouldInterceptRequest(view, request);
}

@Override
public void onReceivedHttpError(WebView view, WebResourceRequest request, WebResourceResponse errorResponse) {
    super.onReceivedHttpError(view, request, errorResponse);
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
        Log.i("htmlError", request.toString() + " \nResponse: " + errorResponse.getReasonPhrase());
    }
}

@Override
public void onReceivedError(WebView view, WebResourceRequest request, WebResourceError error) {
    super.onReceivedError(view, request, error);
    view.loadUrl(Constants.OFFLINE_FILE);
}

@TargetApi(Build.VERSION_CODES.LOLLIPOP)
@Override
public WebResourceResponse shouldInterceptRequest(WebView view, WebResourceRequest rs) {
    if (rs.getUrl().toString().startsWith("http://tutorials.jenkov.com/images/logo.png")) {
        return loadFromAssets(rs.getUrl().toString(), "images/logo.png", "image/png", "");
    }
    return this.urlCache.load(rs.getUrl().toString());
}

@TargetApi(Build.VERSION_CODES.LOLLIPOP)
@Override
public WebResourceResponse shouldInterceptRequest(android.webkit.WebView view, WebResourceRequest request) {
    return mClient != null ? mClient.shouldInterceptRequest(view, request) : super.shouldInterceptRequest(view, request);
}

@Override
public WebResourceResponse shouldInterceptRequest(WebView view, WebResourceRequest request) {
    if (DEBUG)
        Log.d(TAG, "shouldInterceptRequest request=" + request);
    //super.shouldInterceptRequest(view, request);
    return null;
}

@Override
public void onReceivedHttpError(WebView view, WebResourceRequest request, WebResourceResponse errorResponse) {
    onError(null);
}

//--- html 链接打开方式 -----------------------------------------------------------------------
@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
@Override
public boolean shouldOverrideUrlLoading(WebView view, WebResourceRequest request) {
    IntentUtil.openUrl(mContext, request.getUrl().toString());
    return true;
}

public boolean shouldOverrideUrlLoading(WebView view, WebResourceRequest request) {
    return true;
}

@Override
public WebResourceResponse shouldInterceptRequest(WebView webView, WebResourceRequest request) {
    return shouldInterceptRequest(webView, request.getUrl());
}

@TargetApi(Build.VERSION_CODES.M)
@Override
public void onReceivedError(WebView view, WebResourceRequest request, WebResourceError error) {
    // forward to deprecated method
    onReceivedError(view, error.getErrorCode(), error.getDescription().toString(), request.getUrl().toString());
}

@TargetApi(Build.VERSION_CODES.LOLLIPOP)
@Override
public WebResourceResponse shouldInterceptRequest(WebView view, WebResourceRequest request) {
    return shouldInterceptRequest(view, request.getUrl().toString());
}

/*
	 * Uses old deprecated method call and should be removed some day but until then I won't duplicate the code
	 */
@Override
public boolean shouldOverrideUrlLoading(WebView view, final WebResourceRequest request) {
    return shouldOverrideUrlLoading(view, request.getUrl().toString());
}

@Override
public boolean shouldOverrideUrlLoading(WebView view, WebResourceRequest request) {
    startActivity(request.getUrl());
    return true;
}

@Override
public void onReceivedError(WebView view, WebResourceRequest request, WebResourceError error) {
    //            mReloadLayout.setVisibility(View.VISIBLE);
    super.onReceivedError(view, request, error);
}

@TargetApi(Build.VERSION_CODES.N)
@Override
public boolean shouldOverrideUrlLoading(WebView view, WebResourceRequest request) {
    final Uri uri = request.getUrl();
    return handleUri(uri);
}

@Override
public void onReceivedError(WebView view, WebResourceRequest request, WebResourceError error) {
    onError(AuthenticationError.CONNECTIVITY_ISSUE);
}

@Override
public void onReceivedError(WebView view, WebResourceRequest request, WebResourceError error) {
    super.onReceivedError(view, request, error);
    receiver.getTitle("");
}

/**
     * {@inheritDoc}
     * <p/>
     * Handle post lollipop
     */
@Override
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public WebResourceResponse shouldInterceptRequest(WebView view, WebResourceRequest request) {
    WebResourceResponse response = null;
    if (request != null) {
        Uri url = request.getUrl();
        response = handleUrl(url);
    }
    return response;
}

@TargetApi(Build.VERSION_CODES.LOLLIPOP)
@Override
public WebResourceResponse shouldInterceptRequest(WebView view, @NonNull WebResourceRequest request) {
    if (mAdBlock.isAd(request.getUrl().toString())) {
        ByteArrayInputStream EMPTY = new ByteArrayInputStream("".getBytes());
        return new WebResourceResponse("text/plain", "utf-8", EMPTY);
    }
    return super.shouldInterceptRequest(view, request);
}

@SuppressLint("NewApi")
@Override
public boolean shouldOverrideUrlLoading(WebView view, WebResourceRequest request) {
    return shouldOverrideUrlLoading(view, request.getUrl().toString());
}

@Override
public WebResourceResponse shouldInterceptRequest(WebView view, WebResourceRequest request) {
    if (Utils.hasLollipop()) {
        return handleResourceRequest(view, request.getUrl().toString());
    } else {
        return super.shouldInterceptRequest(view, request);
    }
}

@Override
public void onReceivedError(WebView view, WebResourceRequest request, WebResourceError error) {
    super.onReceivedError(view, request, error);
    Snackbar.make(view, "加载错误", Snackbar.LENGTH_LONG).show();
}

@TargetApi(Build.VERSION_CODES.M)
@Override
public void onReceivedError(WebView view, WebResourceRequest request, WebResourceError error) {
    super.onReceivedError(view, request, error);
    onError(view, error.getErrorCode(), error.getDescription().toString(), request.getUrl().toString());
}

@Override
@TargetApi(24)
public boolean shouldOverrideUrlLoading(WebView view, WebResourceRequest request) {
    if (mStarted) {
        handleUrlLoad(request.getUrl());
    }
    return true;
}