वॉली

Question

का उपयोग करते समय एसएसएल अपवाद मैं अपने ऐप अनुरोध करने के लिए एंड्रॉइड में वॉली का उपयोग कर रहा हूं।

com.android.volley.NoConnectionError: javax.net.ssl.SSLHandshakeException: javax.net.ssl.SSLProtocolException: SSL handshake aborted: ssl=0x61e15f78: Failure in SSL library, usually a protocol error 
    error:1407743E:SSL routines:SSL23_GET_SERVER_HELLO:tlsv1 alert inappropriate fallback (external/openssl/ssl/s23_clnt.c:744 0x5b647c58:0x00000000) 

एक ViewPager अंदर मैं दो Fragments, का उपयोग कर रहा है, जो onResume दौरान उनकी सामग्री का अनुरोध: दुर्भाग्य से, मैं निम्नलिखित त्रुटि हो रही है। अनुरोध url मूल रूप से वही है लेकिन एक क्वेरी पैरामीटर के लिए (जो सामग्री के प्रकार को सेट करता है, उदाहरण के लिए प्रवृत्ति बनाम गर्म)।

यूआरएल https://host/api/content?type={hot/trending} रूप में है। अनुरोध हेडर के माध्यम से प्रमाणीकरण किया जाता है।

इस अपवाद के बारे में अजीब हिस्सा यह है कि केवल दो अनुरोधों में से एक विफल रहता है और यह समय-समय पर भिन्न होता है। उनके बीच में देरी जोड़ने के बाद, अपवाद बंद हो गया (विचित्र रूप से कुछ दौड़ की स्थिति को इंगित करता है?)। लेकिन यह एक बुरा कामकाज लगता है और मैं इसे सही तरीके से हल करना चाहता हूं।

इसके बारे में कोई विचार क्या हो सकता है?

संपादित करें:

अनुरोध के रूप में इस मानक तरीका बन जाता है, कतार प्रदान एक सिंगलटन का उपयोग कर,:

final RequestQueue requestQueue = RequestQueueSingleton.getInstance(getActivity()).getRequestQueue(); 
final GsonRequestGet<SearchApiWrapper> gsonRequest = new GsonRequestGet<>(clazz, url,successListener, errorListener); 
gsonRequest.setRetryPolicy(new DefaultRetryPolicy(3000, 3, DefaultRetryPolicy.DEFAULT_BACKOFF_MULT)); 
gsonRequest.setTag(mTag); 
requestQueue.add(gsonRequest); 

और यहाँ सिंगलटन वर्ग है:

public class RequestQueueSingleton { 

    private static RequestQueueSingleton mInstance; 
    private RequestQueue mRequestQueue; 
    private Context mContext; 

    public RequestQueueSingleton(Context context) { 
     mContext = context; 
     mRequestQueue = getRequestQueue(); 
    } 

    /** 
    * Returns a instance of this singleton 
    */ 
    public static synchronized RequestQueueSingleton getInstance(Context context) { 
     if (mInstance == null) { 
      mInstance = new RequestQueueSingleton(context); 
     } 
     return mInstance; 
    } 

    /** 
    * Returns instance of the request queue 
    */ 
    public RequestQueue getRequestQueue() { 
     if (mRequestQueue == null) { 
      mRequestQueue = Volley.newRequestQueue(mContext.getApplicationContext()); 
     } 
     return mRequestQueue; 
    } 
} 

Answer 1

के बाद हमारी टिप्पणियां शायद यह आपकी मदद कर सकती है:

आपका requestQueue:

static { 
    requestQueue = Volley.newRequestQueue(Application.getContext(), new HurlStack(null, ClientSSLSocketFactory.getSocketFactory())); 
} 

ClientSSLSocketFactory:

public class ClientSSLSocketFactory extends SSLCertificateSocketFactory { 
    private SSLContext sslContext; 

    public static SSLSocketFactory getSocketFactory(){ 
     try 
     { 
      X509TrustManager tm = new X509TrustManager() { 
       public void checkClientTrusted(X509Certificate[] xcs, String string) throws CertificateException {} 

       public void checkServerTrusted(X509Certificate[] xcs, String string) throws CertificateException {} 

       public X509Certificate[] getAcceptedIssuers() { 
        return null; 
       } 
      }; 
      sslContext = SSLContext.getInstance("TLS"); 
      sslContext.init(null, new TrustManager[] { tm }, null); 

      SSLSocketFactory ssf = ClientSSLSocketFactory.getDefault(10000, new SSLSessionCache(Application.getInstance())); 

      return ssf; 
     } catch (Exception ex) { 
      return null; 
     } 
    } 

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

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

Answer 2

आयात statments निम्नलिखित जोड़ें।

import javax.net.ssl.TrustManager; 
import javax.net.ssl.HostnameVerifier; 
import javax.net.ssl.HttpsURLConnection; 
import javax.net.ssl.SSLContext; 
import javax.net.ssl.SSLSession; 
import javax.net.ssl.X509TrustManager; 
import java.security.cert.X509Certificate; 
import java.util.ResourceBundle; 

और नेटवर्क कॉल करने से पहले निम्न कोड जोड़ें।

TrustManager[] trustAllCerts = new TrustManager[] { new X509TrustManager() { 
     public java.security.cert.X509Certificate[] getAcceptedIssuers() { 
      return null; 
     } 
     public void checkClientTrusted(X509Certificate[] certs, String authType) { 
     } 
     public void checkServerTrusted(X509Certificate[] certs, String authType) { 
     } 
    } }; 
    SSLContext sc = null; 
    try { 
     sc = SSLContext.getInstance("SSL"); 
    } catch (NoSuchAlgorithmException e) { 
     e.printStackTrace(); 
    } 
    try { 
     sc.init(null, trustAllCerts, new java.security.SecureRandom()); 
    } catch (KeyManagementException e) { 
     e.printStackTrace(); 
    } 
    HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory()); 
    // Create all-trusting host name verifier 
    HostnameVerifier allHostsValid = new HostnameVerifier() { 
     public boolean verify(String hostname, SSLSession session) { 
      return true; 
     } 
    }; 
    // Install the all-trusting host verifier 
    HttpsURLConnection.setDefaultHostnameVerifier(allHostsValid);