Android 使用https的Volley NetworkImageView

我正在应用程序中使用facebook照片。facebook照片存储在https url后面

---

有人能给我举个例子，用https在networkimageview中加载图像吗？

我遇到了类似的问题，不是facebook，而是https下的图像

此外，还有一个自签名证书，加上大量重定向、cookies管理等。。因此，我使用了HttpClient堆栈，现在一切都很好

也许这会对你的问题有所帮助。 您可以跳过所有不感兴趣的部分

初始化HttpClient（您可以跳过不需要的内容） 将HttpClient与Volley一起使用 TrustAllSSLSocketFactory.java

---

这将有助于我想：）我将在一分钟内测试它。谢谢你的帮助！！！

// 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 HttpClientStack with Volley */
mRequestQueue = Volley.newRequestQueue(
    context.getApplicationContext(), new HttpClientStack(client));

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