Получение JSON с https сервера

TrustManager[] trustAllCerts = new TrustManager[]{
                new X509TrustManager() {
                    public java.security.cert.X509Certificate[] getAcceptedIssuers() {
                        return null;
                    }
                    public void checkClientTrusted(
                            java.security.cert.X509Certificate[] certs, String authType) {
                    }
                    public void checkServerTrusted(
                            java.security.cert.X509Certificate[] certs, String authType) {
                    }
                }
        };
        try {
            SSLContext sc = SSLContext.getInstance("TLS");
            sc.init(null, trustAllCerts, new java.security.SecureRandom());
            HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
        } catch (Exception e) {}

URL url = new URL(tasklist);
            HttpURLConnection c = (HttpURLConnection) url.openConnection();
            String temps = new String(edLog.getText().toString()+":"+edPass.getText().toString());
            c.setRequestProperty("Authorization", "basic " + Base64.encode(temps.getBytes(),0));
            c.setUseCaches(false);
            c.connect();

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.URLConnection;
import java.security.cert.CertificateException;
 
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
 
public String executeHttpsGet(String uri) {
            Log. v(LOG_TAG, "Https request -" + uri);
            String strResponse = null;
            BufferedReader reader = null;
             try {
                   // Create a trust manager that does not validate certificate chains
                   final TrustManager[] trustAllCerts = new TrustManager[] { new X509TrustManager() {
 
                         @Override
                         public void checkClientTrusted(
                                    java.security.cert.X509Certificate[] chain,
                                    String authType) throws CertificateException {
                               // TODO Auto-generated method stub
 
                        }
 
                         @Override
                         public void checkServerTrusted(
                                    java.security.cert.X509Certificate[] chain,
                                    String authType) throws CertificateException {
                               // TODO Auto-generated method stub
 
                        }
 
                         @Override
                         public java.security.cert.X509Certificate[] getAcceptedIssuers() {
                               // TODO Auto-generated method stub
                               return null ;
                        }
 
                  } };
 
                   // Install the all-trusting trust manager
                   final SSLContext sslContext = SSLContext.getInstance("SSL");
                  sslContext.init( null, trustAllCerts,
                               new java.security.SecureRandom());
                   // Create an ssl socket factory with our all-trusting manager
                   final javax.net.ssl.SSLSocketFactory sslSocketFactory = sslContext
                              .getSocketFactory();
 
                   // All set up, we can get a resource through https now:
                   final URLConnection connection = new URL(uri).openConnection();
                   // Tell the url connection object to use our socket factory which
                   // bypasses security checks
                  ((HttpsURLConnection) connection)
                              .setSSLSocketFactory(sslSocketFactory);
 
                  reader = new BufferedReader(new InputStreamReader(
                              connection.getInputStream()));
 
                  StringBuffer sb = new StringBuffer("" );
                  String line = "";
                   while ((line = reader.readLine()) != null) {
                        sb.append(line);
                  }
                  strResponse = sb.toString();
                  Log. v(LOG_TAG, "response - " + strResponse);
 
            } catch (final Exception e) {
                  Log. v(LOG_TAG, "HttpsGet failed");
                  e.printStackTrace();
            } finally {
                   if (reader != null) {
                         try {
                              reader.close();
                        } catch (IOException e) {
                              e.printStackTrace();
                        }
                  }
            }
 
             return strResponse;
      }

if (connection instanceof HttpsURLConnection) {
  ((HttpsURLConnection) connection).setHostnameVerifier(new AllowAllHostnameVerifier());
}

reader = new BufferedReader(new InputStreamReader(connection.getInputStream()));

final TrustManager[] trustAllCerts = new TrustManager[] {new X509TrustManager() {
    public X509Certificate[] getAcceptedIssuers() {
        publishProgress("getAcceptedIssuers");
         return null;
    }
    public void checkServerTrusted(X509Certificate[] chain, String authType)
            throws CertificateException {
        publishProgress("Сведения о сертификате : " + chain[0].getIssuerX500Principal().getName() + "\n Тип авторизации : " + authType);
    }
    public void checkClientTrusted(X509Certificate[] chain, String authType)
            throws CertificateException {
        publishProgress("checkClientTrusted : " + authType);
    }
} };

final SSLContext sslContext = SSLContext.getInstance("TLS");
sslContext.init( null, trustAllCerts, new java.security.SecureRandom());
final javax.net.ssl.SSLSocketFactory sslSocketFactory = sslContext.getSocketFactory();

HttpURLConnection conn = (HttpURLConnection) new URL(url).openConnection();

((HttpsURLConnection) conn).setSSLSocketFactory(sslSocketFactory);

((HttpsURLConnection) conn).setHostnameVerifier(new HostnameVerifier() {
    public boolean verify(String arg0, SSLSession arg1) {
        return true;
    }
});

conn.setUseCaches(false);
conn.setDoInput(true);
conn.setReadTimeout(10000 );
conn.setConnectTimeout(15000);
conn.setRequestMethod("GET");

conn.setRequestProperty("Authorization", "Basic " + token);

byte[] enc = Base64.encode("www:www".getBytes("UTF16"), Base64.DEFAULT);

String token = enc.toString();

    static final char base64Array [] = {
        'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
        'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
        'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
        'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
        'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
        'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
        'w', 'x', 'y', 'z', '0', '1', '2', '3',
        '4', '5', '6', '7', '8', '9', '+', '/'
    };
 
    private static String base64Encode (String string)    {
      String encodedString = "";
      byte bytes [] = string.getBytes ();
      int i = 0;
      int pad = 0;
      while (i < bytes.length) {
        byte b1 = bytes [i++];
        byte b2;
        byte b3;
        if (i >= bytes.length) {
           b2 = 0;
           b3 = 0;
           pad = 2;
           }
        else {
           b2 = bytes [i++];
           if (i >= bytes.length) {
              b3 = 0;
              pad = 1;
              }
           else
              b3 = bytes [i++];
           }
        byte c1 = (byte)(b1 >> 2);
        byte c2 = (byte)(((b1 & 0x3) << 4) | (b2 >> 4));
        byte c3 = (byte)(((b2 & 0xf) << 2) | (b3 >> 6));
        byte c4 = (byte)(b3 & 0x3f);
        encodedString += base64Array [c1];
        encodedString += base64Array [c2];
        switch (pad) {
         case 0:
           encodedString += base64Array [c3];
           encodedString += base64Array [c4];
           break;
         case 1:
           encodedString += base64Array [c3];
           encodedString += "=";
           break;
         case 2:
           encodedString += "==";
           break;
         }
        }
        return encodedString;
    }

if (conn.getResponseCode() != HttpURLConnection.HTTP_OK) {
    throw new Exception("http error : " + conn.getResponseCode());
}

BufferedReader in = new BufferedReader(new InputStreamReader(conn.getInputStream()));
String nextLine = null;
while ((nextLine = in.readLine()) != null) {
    sb.append(nextLine);
}
in.close();
conn.disconnect();

byte[] enc = Base64.encode("www:www".getBytes("UTF16"), Base64.DEFAULT);