SSL Exception lors de l'utilisation de Volley

Je suis l'aide de Volley dans Android pour exécuter mon application demande. Malheureusement, j'obtiens l'erreur suivante:

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)

Je suis l'aide de deux Fragments, à l'intérieur d'un ViewPager, qui demande leur contenu au cours de onResume. Les demandes d'url est fondamentalement la même, mais pour un paramètre de requête (ce qui définir le type de contenu, par exemple, les tendances vs chaud).

L'url est de la forme https://host/api/content?type={hot/trending}. L'autorisation est effectuée par le biais de l'entête de la requête.

Ce qui est curieux au sujet de cette exception est que seule l'une des deux requêtes échouent et il varie en qui une de temps en temps. Après j'ai ajouté un décalage entre eux, à l'exception arrêté en cours (bizarrement en faisant ressortir une situation de concurrence?). Mais ce qui semble une mauvaise solution et j'aimerais résoudre ce la bonne manière.

Des pensées sur ce qui pourrait être la cause de cela?

EDIT:

La demande est créée à la norme, à l'aide d'un singleton fournir la file d'attente, comme suit:

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);

Et voici la classe singleton:

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;
    }
}

Comment êtes-vous créer votre Volley RequestQueue?
Jetez un oeil à cette stackoverflow.com/questions/22564317/...
J'ai édité le code pour ajouter la requestQueue création de la logique et de la façon dont je l'utilise.
J'ai étudié que la réponse (et d'autres) avant de poser ma question, malheureusement, ils ne semblent pas s'appliquer à ce cas parce que mes demandes ne travaillent régulièrement. La seule faute de temps, c'est quand ces deux fragments simultanément ajouter leurs demandes à la file d'attente.
Je ne sais pas si c'est la cause de votre si elle n'en résout, mais j'ai l'habitude de créer ma file d'attente comme ceci:

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

OriginalL'auteur Edson Menegatti | 2015-06-18

Après nos observations, peut-être cela peut vous aider:

Votre requestQueue:

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

La 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();
    }
}

Ce n'accepte tous les certificats, droit?
Eh bien, je dirais que oui, parce que quand nous ne sslContext.init(null, new TrustManager[] { tm }, null); nous sommes à l'aide de notre tm qui n'a pas de mise en œuvre. Je n'ai pas le tester, je vais dès que je peux.
Malheureusement, le problème continue à se produire, moins fréquemment, mais passe encore. Toutes les idées sur ce qui pourrait être la cause?
Avec cette approche de la création d'un HurlStack qui permet à tous les certificats SSL donc de votre côté, je ne suis pas ce qui est erroné. Avez-vous accès au serveur? Vous pourriez essayer d'analyser les logs du serveur pour voir si elles offrent tout soupçon.
Il ne fonctionne pas pour moi, sur la 5.0

OriginalL'auteur GuilhE

Ajouter la suite importer des relevés.

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;

et ajoutez le code suivant avant de faire appel du réseau.

    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);

OriginalL'auteur Hammad Tariq

Vous devez vous connecter pour publier un commentaire.