android webView https 5.0以上兼容5.0以下

最新推荐文章于 2021-05-29 04:38:04 发布
最新推荐文章于 2021-05-29 04:38:04 发布
阅读量1.2k 收藏
点赞数
分类专栏： anroid
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TS_learner/article/details/80514158
版权 
  private SSLContext sslContext;
        public MyWebViewClient() {
            prepareSslPinning();
        }

        @Override
        public WebResourceResponse shouldInterceptRequest(final WebView view, String url) {
            Log.d(TAG, "shouldInterceptRequest1:" + url);
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
                return super.shouldInterceptRequest(view,url);
            }else{
                if (!url.startsWith("https")) {
                    return null;
                }
                if (url.endsWith("favicon.ico"))
                    return null;
                return processRequest(Uri.parse(url));
            }


        /*    return null;
//            String url2 = url.replace("http://","https://");
            if (!url.startsWith("https")) {
                return null;
            }
            if (url.endsWith("favicon.ico"))
                return null;
            return processRequest(Uri.parse(url));*/

        }

      /*  @Override
        @TargetApi(Build.VERSION_CODES.LOLLIPOP)
        public WebResourceResponse shouldInterceptRequest(final WebView view, WebResourceRequest interceptedRequest) {
            Log.d(TAG, "shouldInterceptRequest2:");
            return null;
//            String url2 = interceptedRequest.getUrl().toString().replace("http://","https://");
            if (!interceptedRequest.getUrl().toString().startsWith("https")) {
                return null;
            }
            if (interceptedRequest.getUrl().toString().endsWith("favicon.ico"))
                return null;
            return processRequest(interceptedRequest.getUrl());


        }*/

        @Override
        public void onReceivedSslError(WebView view,
                                       SslErrorHandler handler, SslError error) {
            android.util.Log.d(TAG, "onReceivedSslError: " + view.getUrl());
            // TODO Auto-generated method stub
            // handler.cancel();// Android默认的处理方式
            handler.proceed();// 接受所有网站的证书
            // handleMessage(Message msg);// 进行其他处理
//            checkSslError(handler,view.getUrl());

        }
        private void checkSslError(final SslErrorHandler handler,final String url) {
            try {
               OkHttpClient client = SslOkHttpClientUtils.getSslClient(mContext);
               if(client == null){
                   client = new OkHttpClient();
               }
                Request request = new Request.Builder().url(url)
                        .build();

                client.newCall(request).enqueue(new Callback() {
                   @Override
                   public void onFailure(Call call, IOException e) {
                       Log.d(TAG, "checkSslError fail" + e.getMessage());
                       handler.cancel();
                   }

                   @Override
                   public void onResponse(Call call, Response response) throws IOException {
                       Log.d(TAG, "checkSslError success" + response.code());
                       Log.d(TAG, "checkSslError success" + response.body().string());
                       handler.proceed();

                   }
               });
            }catch (Exception e){
                e.printStackTrace();
                android.util.Log.d(TAG, "checkSslError:Exception "+e.getMessage());
            }

        }
        @TargetApi(21)
        @Override
        public void onReceivedClientCertRequest(WebView view, ClientCertRequest request) {
            android.util.Log.d(TAG, "onReceivedClientCertRequest: ");
            if ((null != SslOkHttpClientUtils.clientCertPrivateKey) && ((null != SslOkHttpClientUtils.certificatesChain) && (SslOkHttpClientUtils.certificatesChain.length != 0))) {
                request.proceed(SslOkHttpClientUtils.clientCertPrivateKey, SslOkHttpClientUtils.certificatesChain);
            } else {
                request.cancel();
            }
        }
        private WebResourceResponse processRequest(Uri uri) {
            android.util.Log.d(TAG, "processRequest url: " + uri.toString());
            if (uri.toString().contains("miyoufm/prank/dist/index.html") && SslOkHttpClientUtils.activityCenterSessionId != null) { //活动中心单独使用活动中心的seesion
                SslOkHttpClientUtils.sessionid = SslOkHttpClientUtils.activityCenterSessionId;
            }
            HttpsURLConnection urlConnection = httpsUrlRequest(uri, "GET");
            try {
              /*  android.util.Log.d(TAG, "procesessionid: "+SslOkHttpClientUtils.sessionid);
                GetRequest getRequest = OkGo.get(uri.toString());
                if(SslOkHttpClientUtils.sessionid != null) {
//                    urlConnection.setRequestProperty("Cookie", SslOkHttpClientUtils.sessionid);
                    getRequest.headers("Cookie", SslOkHttpClientUtils.sessionid);
                }
                Response response = getRequest.execute();
                if(response.code() == 405){
                    android.util.Log.d(TAG, "processRequest: "+response.code()+":"+uri.toString());
                }
                android.util.Log.d(TAG, "processRequest: "+response.code()+":"+uri.toString());
                if(response.code() == 200){
                    String cookie = response.header("Set-Cookie");
                    if(cookie != null) {
                        SslOkHttpClientUtils.cookieval = cookie;
                        SslOkHttpClientUtils.sessionid = cookie.substring(0, cookie.indexOf(";"));
                    }
                }
//                String contentType = urlConnection.getContentType();
                String contentType = response.header("content-type");
                String encoding = response.header("content-encoding");
                InputStream inputStream =  response.body().byteStream();
                if (null != contentType){
                    String mimeType = contentType;
                    if (contentType.contains(";")){
                        mimeType = contentType.split(";")[0].trim();
                    }
                    //返回新的response
                    return new WebResourceResponse(mimeType, encoding, inputStream);
                }*/

                //获取请求的内容、contentType、encoding
                android.util.Log.d(TAG, "processRequest: " + urlConnection.getResponseCode() + ":" + uri.toString());
                //若返回405 尝试post请求
                if (urlConnection.getResponseCode() == 405) {
                    urlConnection = httpsUrlRequest(uri, "POST");
                    android.util.Log.d(TAG, "processRequest: " + urlConnection.getResponseCode() + ":" + uri.toString());
                }
                if (urlConnection.getResponseCode() == 200) {
                    String cookie = urlConnection.getHeaderField("Set-Cookie");
                    if (cookie != null) {
                        SslOkHttpClientUtils.cookieval = cookie;
                        SslOkHttpClientUtils.sessionid = cookie.substring(0, cookie.indexOf(";"));
                        if (uri.toString().contains("cmic_adconfiguration/app/index")) {
                            SslOkHttpClientUtils.activityCenterSessionId = cookie.substring(0, cookie.indexOf(";"));
                        }
                    }
                }
                String contentType = urlConnection.getContentType();
                String encoding = urlConnection.getContentEncoding();
                InputStream inputStream = urlConnection.getInputStream();
                if (null != contentType) {
                    String mimeType = contentType;
                    if (contentType.contains(";")) {
                        mimeType = contentType.split(";")[0].trim();
                    }
                    //返回新的response
                    return new WebResourceResponse(mimeType, encoding, inputStream);
                }

            } catch (MalformedURLException e) {
                e.printStackTrace();
                android.util.Log.d(TAG, "MalformedURLException: " + e.getMessage());
            } catch (IOException e) {
                e.printStackTrace();
                android.util.Log.d(TAG, "IOException: " + e.getMessage());
            }/*finally {
                if(urlConnection!=null){
                    urlConnection.disconnect();
                }
            }*/
            return null;
        }

        private HttpsURLConnection httpsUrlRequest(Uri uri, String requstType) {
            HttpsURLConnection urlConnection = null;
            try {
                //设置连接
                URL url = new URL(uri.toString());
                urlConnection = (HttpsURLConnection) url.openConnection();
                android.util.Log.d(TAG, "procesessionid: " + SslOkHttpClientUtils.sessionid);
                if (SslOkHttpClientUtils.sessionid != null) {
                    urlConnection.setRequestProperty("Cookie", SslOkHttpClientUtils.sessionid);
                }

                //为request设置SSL Socket Factory
                urlConnection.setSSLSocketFactory(sslContext.getSocketFactory());
                urlConnection.setConnectTimeout(3000);
                urlConnection.setRequestMethod(requstType);
                urlConnection.setHostnameVerifier(new HostnameVerifier() {
                    @Override
                    public boolean verify(String hostname, SSLSession session) {
                        android.util.Log.d(TAG, "verify: " + hostname);
                        if (hostname.equals("www.wemeetyou.cn") || hostname.equals("221.176.34.113"))
                            return true;
                        return false;
                    }
                });
                return urlConnection;

            } catch (MalformedURLException e) {
                e.printStackTrace();
                android.util.Log.d(TAG, "MalformedURLException: " + e.getMessage());
            } catch (IOException e) {
                e.printStackTrace();
                android.util.Log.d(TAG, "IOException: " + e.getMessage());
            }
            return null;
        }

        private void prepareSslPinning() {
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
                SslOkHttpClientUtils.getCertificates(mContext);
            }else{
                SslOkHttpClientUtils.cookieval = null;
                SslOkHttpClientUtils.sessionid = null;
                SslOkHttpClientUtils.activityCenterSessionId = null;
                sslContext = SslOkHttpClientUtils.getSSLContext(mContext);
            }

        }

public class SslOkHttpClientUtils {
    public static final String TAG = "SslOkHttpClientUtils";

    public static final String KEY_STORE_TYPE_P12 = "PKCS12";//证书类型

    private static OkHttpClient client;
    private static SSLContext sslContext;
    public static String sessionid;
    public static String cookieval;
    public static String activityCenterSessionId;
    public static X509Certificate[] certificatesChain;
    public static PrivateKey clientCertPrivateKey;

    public static OkHttpClient getSslClient(Context context) {
        try {
            if(client == null) {
//                InputStream trustKey = context.getAssets().open("ca.cer");
//                InputStream clientKeyP12 = context.getAssets().open("client.p12");
                InputStream trustKey = context.getAssets().open("ca_test.cer");
                InputStream clientKeyP12 = context.getAssets().open("client_test.p12");
                CertificateFactory certificateFactory = CertificateFactory.getInstance("X.509");
                sslContext = SSLContext.getInstance("TLS");
                KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
                trustStore.load(null);
//                trustStore.load(trustKey, trustPassword.toCharArray());
                trustStore.setCertificateEntry("0", certificateFactory.generateCertificate(trustKey));
                if (trustKey != null) {
                    trustKey.close();
                }
                KeyStore keyStore = KeyStore.getInstance(KEY_STORE_TYPE_P12);
                keyStore.load(clientKeyP12, "123456".toCharArray());
              /*  KeyStore keyStore = KeyStore.getInstance("BKS");
                keyStore.load(clientKeyP12, clientPassword.toCharArray());*/
                    TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
                    trustManagerFactory.init(trustStore);
                    TrustManager[] trustManagers = trustManagerFactory.getTrustManagers();
                    if (trustManagers.length != 1 || !(trustManagers[0] instanceof X509TrustManager)) {
                        throw new IllegalStateException("Unexpected default trust managers:" + Arrays.toString(trustManagers));
                    }
                    X509TrustManager trustManager = (X509TrustManager) trustManagers[0];
                    KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
                    keyManagerFactory.init(keyStore, "123456".toCharArray());
                    sslContext.init(keyManagerFactory.getKeyManagers(), trustManagerFactory.getTrustManagers(), new SecureRandom());
                    client =  new OkHttpClient().newBuilder()
                            .sslSocketFactory(sslContext.getSocketFactory(), trustManager)
                            .followRedirects(false)
                            .followSslRedirects(false)
                            .hostnameVerifier(new HostnameVerifier() {
                                @Override
                                public boolean verify(String hostname, SSLSession session) {
                                    Log.d(TAG, "verify: "+hostname);
                                    if(hostname.equals("www.wemeetyou.cn") || hostname.equals("221.176.34.113"))
                                        return true;
                                    return false;
                                }
                            })
                            .build();
                return client;
            }
            return client;
        } catch (Exception e) {
            e.printStackTrace();
            android.util.Log.d(TAG, "exception222:"+e.toString());
            return null;
        }
    }
    public static SSLContext getSSLContext(Context context){
        try {
            if(sslContext == null) {
//                InputStream trustKey = context.getAssets().open("ca.cer");
//                InputStream clientKeyP12 = context.getAssets().open("client.bks");
                InputStream trustKey = context.getAssets().open("ca_test.cer");
                InputStream clientKeyP12 = context.getAssets().open("client_test.bks");
                sslContext = SSLContext.getInstance("TLS");
                KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
                KeyStore keyStore = KeyStore.getInstance("BKS");
                keyStore.load(clientKeyP12, "123456".toCharArray());
                clientKeyP12.close();
                trustStore.load(null);
                Log.d(TAG, "getSSLContext: 1");
                CertificateFactory certificateFactory = CertificateFactory.getInstance("X.509");
                trustStore.setCertificateEntry("0", certificateFactory.generateCertificate(trustKey));
                if (trustKey != null) {
                    trustKey.close();
                }
                TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance("X509");
                KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance("X509");
                trustManagerFactory.init(trustStore);
                keyManagerFactory.init(keyStore, "123456".toCharArray());
                sslContext.init(keyManagerFactory.getKeyManagers(), trustManagerFactory.getTrustManagers(), null);
                Log.d(TAG, "getSSLContext: success");
            }
            return sslContext;
        } catch (Exception e) {
            e.printStackTrace();
            android.util.Log.d(TAG, "exception222:"+e.toString());
            return null;
        }

    }

    public static void getCertificates(Context context){
        if(clientCertPrivateKey == null) {
            try {

                KeyStore clientKeyStore = KeyStore.getInstance("PKCS12");
//                clientKeyStore.load(context.getAssets().open("client.p12"), "123456".toCharArray());
                clientKeyStore.load(context.getAssets().open("client_test.p12"), "123456".toCharArray());
                Enumeration<?> localEnumeration;
                localEnumeration = clientKeyStore.aliases();
                while (localEnumeration.hasMoreElements()) {
                    String str3 = (String) localEnumeration.nextElement();
                    clientCertPrivateKey = (PrivateKey) clientKeyStore.getKey(str3, "123456".toCharArray());
                    if (clientCertPrivateKey != null) {
                        Certificate[] arrayOfCertificate = clientKeyStore.getCertificateChain(str3);
                        certificatesChain = new X509Certificate[arrayOfCertificate.length];
                        for (int j = 0; j < certificatesChain.length; j++) {
                            certificatesChain[j] = ((X509Certificate) arrayOfCertificate[j]);
                        }
                    }
                }

            } catch (IOException e) {
                e.printStackTrace();
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
            } catch (KeyStoreException e) {
                e.printStackTrace();
            } catch (CertificateException e) {
                e.printStackTrace();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

}


ts_learner
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
android使用webview上传文件兼容问题解决支持5.0以上系统
07-20
android使用webview上传文件兼容问题解决，兼容5.0以上系统
Android5.0 WebView中Http和Https混合问题
旭日的芬芳
06-29 2万+
场景复现: 在Android5.0 以及以上的系统，当WebView加载的链接为Https开头，但是链接里面的内容，比如图片为Http链接，这时候，图片就会加载不出来，在浏览器中的Console会有如下警告log: 原因： 从Android5.0开始，WebView默认不支持同时加载Https和Http混合模式。 知识储备： 从Android5.0以后，当一个
android 兼容5.0系统,android使用webview上传文件兼容问题解决支持5.0以上系统
weixin_39556702的博客
05-29 195
【实例简介】android使用webview上传文件兼容问题解决，兼容5.0以上系统【实例截图】【核心代码】WebViewUpload└── WebViewUpload├── AndroidManifest.xml├── assets│ └── up.html├── bin│ ├── AndroidManifest.xml│ ├── classes│ │ ├── android...
个人整理的android webview的一些适配方案：
qq_32503241的博客
08-11 945
webview的适配方案： 1.支持js：settings.setJavaScriptEnabled(true); 2.跳转到外部浏览器下载： webView.setDownloadListener(new DownloadListener() { @Override public void onDownloadStart(String s, String s1, String s2, String s3, long l)
AndroidX WebView Crash 5.0&5.1
Krisez的博客
12-23 1712
版本库迁移至AndroidX后，WebView在5.0&5.1设备上引起App崩溃 当前AndroidX版本1.1.0 stackoverflo的帖子 两个方案： 1、针对WebView复写 public class LollipopFixedWebView extends WebView { public LollipopFixedWebView(Context context)...
快速解决android webview https图片不显示的问题
08-27
然而，随着网络安全的提升，从Android Lollipop（5.0）版本开始，WebView引入了一项安全策略，即默认禁止混合内容（Mixed Content）。这意味着在启用HTTPS的网页中，WebView将不允许加载HTTP协议的资源，包括图片、...
详解Android WebView的input上传照片的兼容问题
08-29
- 在Android 5.0及以上版本，系统引入了`onShowFileChooser()`方法，需要提供一个`ValueCallback[]>`，并且可能需要处理`FileChooserParams`对象。 3. 使用Intent启动相机或相册： 在`openFileChooser()`系列方法...
Android webview打开本地图片上传实现代码
08-31
// 对于Android 5.0以下版本，可能需要通过其他方式触发 } } }); ``` 最后，确保在AndroidManifest.xml中添加了读取存储权限，因为我们需要访问用户的文件系统： ```xml <uses-permission android:name=...
Android WebView那些坑之上传文件示例
08-31
4. 最后，对于Android 5.0及更高版本，`onShowFileChooser(WebView, ValueCallback[]>, WebChromeClient.FileChooserParams)`被引入，此方法提供了更丰富的参数控制，如多选文件等。 在上述方法中，我们需要创建一...
Android怎么使用高版本的Webview
IT先森
07-07 5212
    Android怎么使用高版本的Webview 前言   最近客户提出一个问题，就是由于Android的内置版本WebView版本过低，用户希望能使用高版本的WebView。这个问题有两种解决办法，第一就是系统将内置WebView版本提供，第二就是客户需要使用什么版本的WebView，自行下载然后固件将客户下载的版本作为默认版本。下面就在Android 5.1和7.1的版本上面分别实施。 ...
Android中使用WebSocket实现群聊和消息推送功能(不使用WebView)
01-04
WebSocket protocol 是HTML5一种新的协议。它实现了浏览器与服务器全双工通信(full-duplex)。WebSocket是Web2.0时代的新产物，用于弥补HTTP协议的某些不足，不过他们之间真实的关系是兄弟关系，都是对socket的进一步封装，其目前最直观的表现就是服务器推送和聊天功能。更多知识参考：如何理解 TCP/IP, SPDY, WebSocket 三者之间的关系？ 今天的重点是讲如何在Android中脱离WebView使用WebSocket，而不是在Web浏览器使用，如果是在Web浏览器中使用，网上已经太多教程、框架和demo，没必要讲。 到目前为止我个人认为
Android通过WEBVIEW调用HTTPS
10-21
Android通过WEBVIEW调用HTTPS
Android5.0以上WebView的兼容问题
qq_26585943的博客
01-17 1万+
最近在维护一个项目同时要兼容Android4.4和Android5.0两种机型，在调试Android5.0的时候多次因为WebView而造成程序崩溃。在项目完成之后，就来总结一下WebView的兼容性问题。1. All WebView methods must be called on the same thread. 在Android5.0，WebView添加了线程检测，要求WebView的所有
android5.0版本适配
Android Engineer.
07-03 967
android 5.0版本适配：WebView、Service、MaterialDesign
WebView适配问题汇总（持续更新）
Ever69的博客
02-29 1396
1、网页图片宽高过大 有些时候，我们用WebView加载的网页没有对移动端进行适配，导致网页中的图片超出屏幕大小，影响显示效果，这时我们就需要对WebView进行设置使网页中的图片大小适配移动端。 通过js脚本，重置img标签中图片的宽度和高度。 //开启javascript支持 webView.getSettings().setJavaScriptEnabled(true...
Android webview在https下实现ssl的双向认证
zx的博客
12-02 4412
这篇文章的重点是实现SSL证书双向认证，包含： a.生成客户端与服务端证书。 b.搭建支持Https的服务器。 c.实现webview的双向证书认证。
Android 各个版本WebView
热门推荐
typename 记录点滴
10-27 11万+
介绍Android 4.0及其以上版本的WebView内部结构实现以及WebView的渲染方式，WebKit for WebView VS Chromium for WebView。 各个Android Webview版本的变化。
golang websocket绑定用户_基于websocket单台机器支持百万连接分布式聊天(IM)系统
weixin_39669075的博客
11-21 881
本文将介绍如何实现一个基于websocket分布式聊天(IM)系统。使用golang实现websocket通讯，单机可以支持百万连接，使用gin框架、nginx负载、可以水平部署、程序内部相互通讯、使用grpc通讯协议。本文内容比较长，如果直接想clone项目体验直接进入项目体验 goWebSocket项目下载 ,文本从介绍webSocket是什么开始，然后开始介绍这个项目，以及在Nginx中配置...
android webview https ssl
最新发布
10-29
Android提供了WebView控件来加载和显示Web页面。在使用WebView加载HTTPS网页时，SSL（即Secure Sockets Layer）是必需的。...通过以上步骤，我们就可以在Android WebView中加载HTTPS安全网页并保持通信的安全性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值