Volley NetworkImageView using https

Question

I am using facebook photo's in my app. The facebook photo's are stored behind a https url.

Can somebody give me an example to load an image with the networkimageview using https?

Answer 1

I had similar problems, not with facebook, but with images under https.

Besides there was a self-signed certificate, plus a lot of redirect, cookies management etc.. So I used HttpClient Stack with Volley and now everything works great.

Maybe this could be helpful for your problem. You can skip all the all the parts that do not interest you.

Initialize HttpClient (you can skip what don't need)

// Create and initialize HTTP parameters
HttpParams params = new BasicHttpParams();
HttpClientParams.setRedirecting(params, true );

// Set the timeout in milliseconds until a connection is established.
HttpConnectionParams.setConnectionTimeout( params, 5000 );

// Set the default socket timeout (SO_TIMEOUT)
// in milliseconds which is the timeout for waiting for data.
HttpConnectionParams.setSoTimeout( params, 10000 );

// The params are read in the ctor of the pool constructed by
// ThreadSafeClientConnManager, and need to be set before constructing it.
ConnManagerParams.setMaxTotalConnections(params, 15);
ConnPerRoute cpr = new ConnPerRoute() {
   @Override
   public int getMaxForRoute(HttpRoute httpRoute) { return 5; }
};

ConnManagerParams.setMaxConnectionsPerRoute(params, cpr);

HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);

// Create and initialize scheme registry
SchemeRegistry schemeRegistry = new SchemeRegistry();
schemeRegistry.register( new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));

/* Since I'm in a development environment I need to trust self-signed certs */
SSLSocketFactory sslSocketFactory = null;
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 ctx = SSLContext.getInstance("TLS");
   ctx.init(null, new TrustManager[]{tm}, null);

   sslSocketFactory = new TrustAllSSLSocketFactory(ctx);
   if (sslSocketFactory != null)
      sslSocketFactory.setHostnameVerifier(
          SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);

} catch (Exception ex) {
   Log.e(TAG, ex.getMessage(), ex);
   sslSocketFactory = null;
}

if (sslSocketFactory == null) {
   sslSocketFactory = SSLSocketFactory.getSocketFactory();
   sslSocketFactory.setHostnameVerifier(
      SSLSocketFactory.BROWSER_COMPATIBLE_HOSTNAME_VERIFIER);
}

schemeRegistry.register(new Scheme("https", sslSocketFactory, 443));

// Create an HttpClient with the ThreadSafeClientConnManager.
// This connection manager must be used if more than one thread will
// be using the HttpClient.
ClientConnectionManager cm = new ThreadSafeClientConnManager(params, schemeRegistry);

DefaultHttpClient client = new DefaultHttpClient(cm, params);

HttpProtocolParams.setUseExpectContinue(client.getParams(), false);

HttpRequestRetryHandler retryHandler = new HttpRequestRetryHandler() {
   public boolean retryRequest(IOException exception, int executionCount,
      HttpContext context) {
      // retry a max of 5 times
      if(executionCount >= 5) { return false; }
      if(exception instanceof NoHttpResponseException){
         return true;
      } else if (exception instanceof ClientProtocolException){
         return true;
      }
      return false;
   }
};

client.setHttpRequestRetryHandler(retryHandler);

/* Cookie Management */
CookiesStore cookieStore = new BasicCookieStore();
client.setCookieStore(cookieStore);

Use HttpClient with Volley

/* Use HttpClientStack with Volley */
mRequestQueue = Volley.newRequestQueue(
    context.getApplicationContext(), new HttpClientStack(client));

TrustAllSSLSocketFactory.java

static final
private class TrustAllSSLSocketFactory extends SSLSocketFactory {

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

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

  public TrustAllSSLSocketFactory(SSLContext context)
      throws KeyManagementException, 
             NoSuchAlgorithmException, KeyStoreException, 
             UnrecoverableKeyException {
    super(null);
    sslContext = context;
  }

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