HttpsClient单向认证 不校验服务器证书

获取 HttpsClient单例：

if(getUrl().contains("https://")){
mClient = getHttpsClient();
}

private synchronized static AsyncHttpClient getHttpsClient(){
        if(httpsClient == null){
            httpsClient = new AsyncHttpClient();
            httpsClient.setMaxConnections(3);
            httpsClient.setTimeout(timeOut);
            httpsClient.addHeader("Locale", "ZH_cn");      
            httpsClient.addHeader("Accept", "text/html,application/json,application/xhtml+xml,application/xml");
            httpsClient.addHeader("Accept-Language", "zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3");

            SSLSocketFactory sf = SSLCustomSocketFactory.getSocketFactory(); //单向认证 不校验服务器证书
            if(sf != null){
                httpsClient.setSSLSocketFactory(sf);
            }
            HttpProtocolParams.setUseExpectContinue(httpsClient.getHttpClient().getParams(), false);
        }

        return httpsClient;
    }

public static class SSLCustomSocketFactory extends SSLSocketFactory {
        private static final String TAG = "SSLCustomSocketFactory";

        SSLContext sslContext = SSLContext.getInstance("TLS");

        public SSLCustomSocketFactory(KeyStore truststore) throws NoSuchAlgorithmException, KeyManagementException,
                KeyStoreException, UnrecoverableKeyException {
            super(truststore);

            TrustManager tm = new X509TrustManager() {

                @Override
                public X509Certificate[] getAcceptedIssuers() {
                    return null;
                }

                @Override
                public void checkServerTrusted(X509Certificate[] chain,
                                               String authType) throws CertificateException {

                }

                @Override
                public void checkClientTrusted(X509Certificate[] chain,
                                               String authType) throws CertificateException {

                }
            };

            sslContext.init(null, new TrustManager[] { tm }, null);

        }

        @Override
        public Socket createSocket(Socket socket, String host, int port,
                                   boolean autoClose) throws IOException, UnknownHostException {
            injectHostname(socket, host);
            return sslContext.getSocketFactory().createSocket(socket, host,
                    port, autoClose);
        }

        @Override
        public Socket createSocket() throws IOException {
            return sslContext.getSocketFactory().createSocket();
        }

        private void injectHostname(Socket socket, String host) {
            try {
                Field field = InetAddress.class.getDeclaredField("hostName");
                field.setAccessible(true);
                field.set(socket.getInetAddress(), host);
            } catch (Exception ignored) {

            }
        }

        public static SSLSocketFactory getSocketFactory(){
            try {
                KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
                trustStore.load(null, null);
                SSLSocketFactory factory = new SSLCustomSocketFactory(trustStore);
                factory.setHostnameVerifier(SSLCustomSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
                return factory;
            }catch (Exception e){
                logger.w("%s", e.getMessage());
                e.printStackTrace();
            }

            return null;
        }

    }