public static String httpGetSSL(final String exist, String database, String android_id)
throws IOException, HttpHostConnectException, ConnectException {
String getUrl = "https://" + exist + ":50001/exist/rest/db/calendar/" + android_id + ".xml";
LogHelper.logV(c, "httpGetSSL: " + getUrl);
SchemeRegistry schemeRegistry = new SchemeRegistry();
// schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(),
// 80));
schemeRegistry.register(new Scheme("https", SSLSocketFactory.getSocketFactory(), 443));
DefaultHttpClient httpClient = new DefaultHttpClient();
HttpParams params = httpClient.getParams();
ClientConnectionManager ccm = new SingleClientConnManager(params, schemeRegistry);
httpClient =
new DefaultHttpClient(new ThreadSafeClientConnManager(params, schemeRegistry), params);
httpClient.setRedirectHandler(new DefaultRedirectHandler());
HttpGet get = new HttpGet(getUrl);
get.setHeader("Location", database + ":50082");
get.setHeader("Connection", "close");
HttpResponse response = httpClient.execute(get);
HttpEntity httpEntity = response.getEntity();
return EntityUtils.toString(httpEntity);
}
public static synchronized HttpClient getHttpClient() {
if (null == customerHttpClient) {
HttpParams params = new BasicHttpParams();
HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);
HttpProtocolParams.setContentCharset(params, CHARSET);
HttpProtocolParams.setUseExpectContinue(params, true);
HttpProtocolParams.setUserAgent(
params,
"Mozilla/5.0(Linux;U;Android 2.2.1;en-us;Nexus One Build.FRG83) "
+ "AppleWebKit/553.1(KHTML,like Gecko) Version/4.0 Mobile Safari/533.1");
// 从连接池中取连续的超时时间
ConnManagerParams.setTimeout(params, 1000);
HttpConnectionParams.setConnectionTimeout(params, 2000);
HttpConnectionParams.setSoTimeout(params, 4000);
// 设置我们的HttpClient支持HTTP和HTTPS两种模式
SchemeRegistry schReg = new SchemeRegistry();
schReg.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
schReg.register(new Scheme("https", SSLSocketFactory.getSocketFactory(), 443));
// 使用线程安全的连接管理来创建HttpClient
ClientConnectionManager conMgr = new ThreadSafeClientConnManager(params, schReg);
customerHttpClient = new DefaultHttpClient(conMgr, params);
}
return customerHttpClient;
}
@Override
protected ClientConnectionManager createClientConnectionManager() {
SchemeRegistry registry = new SchemeRegistry();
registry.register(new Scheme("http", 80, PlainSocketFactory.getSocketFactory()));
registry.register(new Scheme("https", 443, SSLSocketFactory.getSocketFactory()));
ClientConnectionManager connManager = null;
HttpParams params = getParams();
ClientConnectionManagerFactory factory = null;
String className =
(String) params.getParameter(ClientPNames.CONNECTION_MANAGER_FACTORY_CLASS_NAME);
if (className != null) {
try {
Class<?> clazz = Class.forName(className);
factory = (ClientConnectionManagerFactory) clazz.newInstance();
} catch (ClassNotFoundException ex) {
throw new IllegalStateException("Invalid class name: " + className);
} catch (IllegalAccessException ex) {
throw new IllegalAccessError(ex.getMessage());
} catch (InstantiationException ex) {
throw new InstantiationError(ex.getMessage());
}
}
if (factory != null) {
connManager = factory.newInstance(params, registry);
} else {
connManager = new SingleClientConnManager(registry);
}
return connManager;
}
/**
* Static method to initialize HTTP client. Notice the double instance == null check. By
* checking in and outside of the synchronization, this method is threadsafe. It ensures the
* singleton is only instantiated once.
*
* @return
*/
public HttpClient getInstance() {
if (INSTANCE == null) {
synchronized (HttpConnectionManager.class) {
if (INSTANCE == null) {
final HttpParams params = new BasicHttpParams();
final SchemeRegistry registry = new SchemeRegistry();
final SSLSocketFactory sslSocketFactory = SSLSocketFactory.getSocketFactory();
HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);
HttpProtocolParams.setContentCharset(params, "utf-8");
HttpProtocolParams.setUserAgent(params, "Basedroid");
sslSocketFactory.setHostnameVerifier(
SSLSocketFactory.BROWSER_COMPATIBLE_HOSTNAME_VERIFIER);
registry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
registry.register(new Scheme("https", sslSocketFactory, 443));
final ClientConnectionManager manager =
new ThreadSafeClientConnManager(params, registry);
INSTANCE = new DefaultHttpClient(manager, params);
}
}
}
return INSTANCE;
}
protected DefaultHttpClient getHttpClient() {
if (httpClient == null) {
HttpParams httpParams = new BasicHttpParams();
HttpProtocolParams.setVersion(httpParams, HttpVersion.HTTP_1_1);
HttpProtocolParams.setContentCharset(httpParams, HTTP.UTF_8);
HttpProtocolParams.setUseExpectContinue(
httpParams, false); // some webservers have problems if this is set to true
ConnManagerParams.setMaxTotalConnections(httpParams, MAX_TOTAL_CONNECTIONS);
HttpConnectionParams.setConnectionTimeout(httpParams, CONNECTION_TIMEOUT);
HttpConnectionParams.setSoTimeout(httpParams, SOCKET_TIMEOUT);
// httpParams.setParameter(ConnRoutePNames.DEFAULT_PROXY, new
// HttpHost("192.168.16.180", 8888, "http"));
httpParams.setParameter(ClientPNames.COOKIE_POLICY, CookiePolicy.RFC_2109);
SchemeRegistry schemeRegistry = new SchemeRegistry();
schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
schemeRegistry.register(new Scheme("https", SSLSocketFactory.getSocketFactory(), 443));
ClientConnectionManager connectionManager =
new ThreadSafeClientConnManager(httpParams, schemeRegistry);
httpClient = new DefaultHttpClient(connectionManager, httpParams);
}
return httpClient;
}
/**
* Create a new HttpClient with reasonable defaults (which you can update).
*
* @param userAgent to report in your HTTP requests.
* @return AndroidHttpClient for you to use for all your requests.
*/
public static AndroidHttpClient newInstance(String userAgent) {
HttpParams params = new BasicHttpParams();
// Turn off stale checking. Our connections break all the time anyway,
// and it's not worth it to pay the penalty of checking every time.
HttpConnectionParams.setStaleCheckingEnabled(params, false);
// Default connection and socket timeout of 20 seconds. Tweak to taste.
HttpConnectionParams.setConnectionTimeout(params, 20 * 1000);
HttpConnectionParams.setSoTimeout(params, 20 * 1000);
HttpConnectionParams.setSocketBufferSize(params, 8192);
// Don't handle redirects -- return them to the caller. Our code
// often wants to re-POST after a redirect, which we must do ourselves.
HttpClientParams.setRedirecting(params, false);
// Set the specified user agent and register standard protocols.
HttpProtocolParams.setUserAgent(params, userAgent);
SchemeRegistry schemeRegistry = new SchemeRegistry();
schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
schemeRegistry.register(new Scheme("https", SSLSocketFactory.getSocketFactory(), 443));
ClientConnectionManager manager = new ThreadSafeClientConnManager(params, schemeRegistry);
// We use a factory method to modify superclass initialization
// parameters without the funny call-a-static-method dance.
return new AndroidHttpClient(manager, params);
}
private static SSLSocketFactory getSocketFactory(Boolean d) {
// Enable debug mode to ignore all certificates
if (DEBUG) {
KeyStore trustStore;
try {
trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
trustStore.load(null, null);
SSLSocketFactory sf = new DebugSSLSocketFactory(trustStore);
sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
return sf;
} catch (KeyStoreException e2) {
// TODO Auto-generated catch block
e2.printStackTrace();
} catch (NoSuchAlgorithmException e3) {
// TODO Auto-generated catch block
e3.printStackTrace();
} catch (CertificateException e3) {
// TODO Auto-generated catch block
e3.printStackTrace();
} catch (IOException e3) {
// TODO Auto-generated catch block
e3.printStackTrace();
} catch (KeyManagementException e2) {
// TODO Auto-generated catch block
e2.printStackTrace();
} catch (UnrecoverableKeyException e2) {
// TODO Auto-generated catch block
e2.printStackTrace();
}
}
return SSLSocketFactory.getSocketFactory();
}
/**
* Returns default instance of SchemeRegistry
*
* @param fixNoHttpResponseException Whether to fix or not issue, by ommiting SSL verification
* @param httpPort HTTP port to be used, must be greater than 0
* @param httpsPort HTTPS port to be used, must be greater than 0
*/
private static SchemeRegistry getDefaultSchemeRegistry(
boolean fixNoHttpResponseException, int httpPort, int httpsPort) {
if (fixNoHttpResponseException) {
Log.d(LOG_TAG, "Beware! Using the fix is insecure, as it doesn't verify SSL certificates.");
}
if (httpPort < 1) {
httpPort = 80;
Log.d(LOG_TAG, "Invalid HTTP port number specified, defaulting to 80");
}
if (httpsPort < 1) {
httpsPort = 443;
Log.d(LOG_TAG, "Invalid HTTPS port number specified, defaulting to 443");
}
// Fix to SSL flaw in API < ICS
// See https://code.google.com/p/android/issues/detail?id=13117
SSLSocketFactory sslSocketFactory;
if (fixNoHttpResponseException) sslSocketFactory = MySSLSocketFactory.getFixedSocketFactory();
else sslSocketFactory = SSLSocketFactory.getSocketFactory();
SchemeRegistry schemeRegistry = new SchemeRegistry();
schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), httpPort));
schemeRegistry.register(new Scheme("https", sslSocketFactory, httpsPort));
return schemeRegistry;
}
/**
* Creates SSLSockets that don't use the SSLv2Hello protocol. This is primarily to work around
* TripIt.coms SSL... quirks.
*/
private static final class CustomSSLSocketFactory implements LayeredSocketFactory {
private final LayeredSocketFactory factory = SSLSocketFactory.getSocketFactory();
private final String protocol;
public CustomSSLSocketFactory(String protocol) {
this.protocol = protocol;
}
public Socket createSocket() throws IOException {
SSLSocket socket = (SSLSocket) factory.createSocket();
socket.setEnabledProtocols(new String[] {protocol});
return socket;
}
public Socket connectSocket(
Socket sock,
String host,
int port,
InetAddress localAddress,
int localPort,
HttpParams params)
throws IOException, UnknownHostException, ConnectTimeoutException {
return factory.connectSocket(sock, host, port, localAddress, localPort, params);
}
public boolean isSecure(Socket sock) throws IllegalArgumentException {
return factory.isSecure(sock);
}
public Socket createSocket(Socket socket, String host, int port, boolean autoClose)
throws IOException, UnknownHostException {
return factory.createSocket(socket, host, port, autoClose);
}
}
private static HttpClient setupHttpClient(boolean gzip) {
SSLSocketFactory.getSocketFactory()
.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
SchemeRegistry schemeRegistry = new SchemeRegistry();
schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
schemeRegistry.register(new Scheme("https", SSLSocketFactory.getSocketFactory(), 443));
BasicHttpParams params = new BasicHttpParams();
params.setParameter(ConnManagerPNames.MAX_CONNECTIONS_PER_ROUTE, new ConnPerRouteBean(20));
params.setIntParameter(ConnManagerPNames.MAX_TOTAL_CONNECTIONS, 200);
ThreadSafeClientConnManager cm = new ThreadSafeClientConnManager(params, schemeRegistry);
DefaultHttpClient httpClient = new DefaultHttpClient(cm, new BasicHttpParams());
httpClient.setHttpRequestRetryHandler(
new DefaultHttpRequestRetryHandler(HTTP_RETRY_COUNT, true));
if (gzip) {
httpClient.addRequestInterceptor(
new HttpRequestInterceptor() {
public void process(HttpRequest request, HttpContext context)
throws HttpException, IOException {
if (!request.containsHeader("Accept-Encoding")) {
request.addHeader("Accept-Encoding", "gzip");
}
}
});
httpClient.addResponseInterceptor(
new HttpResponseInterceptor() {
public void process(HttpResponse response, HttpContext context)
throws HttpException, IOException {
HttpEntity entity = response.getEntity();
Header ceheader = entity.getContentEncoding();
if (ceheader != null) {
HeaderElement[] codecs = ceheader.getElements();
for (int i = 0; i < codecs.length; i++) {
if (codecs[i].getName().equalsIgnoreCase("gzip")) {
response.setEntity(new GzipDecompressingEntity(response.getEntity()));
return;
}
}
}
}
});
}
return httpClient;
}
/** Creates a new AsyncHttpClient. */
public AsyncHttpClient() {
BasicHttpParams httpParams = new BasicHttpParams();
ConnManagerParams.setTimeout(httpParams, socketTimeout);
ConnManagerParams.setMaxConnectionsPerRoute(httpParams, new ConnPerRouteBean(maxConnections));
ConnManagerParams.setMaxTotalConnections(httpParams, DEFAULT_MAX_CONNECTIONS);
HttpConnectionParams.setSoTimeout(httpParams, socketTimeout);
HttpConnectionParams.setTcpNoDelay(httpParams, true);
HttpConnectionParams.setSocketBufferSize(httpParams, DEFAULT_SOCKET_BUFFER_SIZE);
HttpProtocolParams.setVersion(httpParams, HttpVersion.HTTP_1_1);
HttpProtocolParams.setUserAgent(
httpParams,
String.format("android-async-http/%s (http://loopj.com/android-async-http)", VERSION));
SchemeRegistry schemeRegistry = new SchemeRegistry();
schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
schemeRegistry.register(new Scheme("https", SSLSocketFactory.getSocketFactory(), 443));
ThreadSafeClientConnManager cm = new ThreadSafeClientConnManager(httpParams, schemeRegistry);
httpContext = new SyncBasicHttpContext(new BasicHttpContext());
httpClient = new DefaultHttpClient(cm, httpParams);
httpClient.addRequestInterceptor(
new HttpRequestInterceptor() {
public void process(HttpRequest request, HttpContext context) {
if (!request.containsHeader(HEADER_ACCEPT_ENCODING)) {
request.addHeader(HEADER_ACCEPT_ENCODING, ENCODING_GZIP);
}
for (String header : clientHeaderMap.keySet()) {
request.addHeader(header, clientHeaderMap.get(header));
}
}
});
httpClient.addResponseInterceptor(
new HttpResponseInterceptor() {
public void process(HttpResponse response, HttpContext context) {
final HttpEntity entity = response.getEntity();
final Header encoding = entity.getContentEncoding();
if (encoding != null) {
for (HeaderElement element : encoding.getElements()) {
if (element.getName().equalsIgnoreCase(ENCODING_GZIP)) {
response.setEntity(new InflatingEntity(response.getEntity()));
break;
}
}
}
}
});
httpClient.setHttpRequestRetryHandler(new RetryHandler(DEFAULT_MAX_RETRIES));
threadPool = (ThreadPoolExecutor) Executors.newCachedThreadPool();
requestMap = new WeakHashMap<Context, List<WeakReference<Future<?>>>>();
clientHeaderMap = new HashMap<String, String>();
}
// 每次都返回新的HttpClient实例
public static HttpClient getNewInstance(Context mContext) {
HttpClient newInstance;
HttpParams params = new BasicHttpParams();
HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);
HttpProtocolParams.setContentCharset(params, HTTP.DEFAULT_CONTENT_CHARSET);
HttpProtocolParams.setUseExpectContinue(params, true);
// 自定义三个timeout参数
/*
* 1.set a timeout for the connection manager,it defines how long we
* should wait to get a connection out of the connection pool managed by
* the connection manager
*/
ConnManagerParams.setTimeout(params, 5000);
/*
* 2.The second timeout value defines how long we should wait to make a
* connection over the network to the server on the other end
*/
HttpConnectionParams.setConnectionTimeout(params, TIMEOUT);
/*
* 3.we set a socket timeout value to 4 seconds to define how long we
* should wait to get data back for our request.
*/
HttpConnectionParams.setSoTimeout(params, TIMEOUT_SOCKET);
SchemeRegistry schReg = new SchemeRegistry();
schReg.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
schReg.register(new Scheme("https", SSLSocketFactory.getSocketFactory(), 443));
ClientConnectionManager conMgr = new ThreadSafeClientConnManager(params, schReg);
newInstance = new DefaultHttpClient(conMgr, params);
switch (checkNetworkType(mContext)) {
case TYPE_CT_WAP:
{
// 通过代理解决中国移动联通GPRS中wap无法访问的问题
HttpHost proxy = new HttpHost("10.0.0.200", 80, "http");
newInstance.getParams().setParameter(ConnRoutePNames.DEFAULT_PROXY, proxy);
Logs.v("当前网络类型为cm_cu_wap,设置代理10.0.0.200访问www");
}
break;
case TYPE_CM_CU_WAP:
{
// 通过代理解决中国移动联通GPRS中wap无法访问的问题
HttpHost proxy = new HttpHost("10.0.0.172", 80, "http");
newInstance.getParams().setParameter(ConnRoutePNames.DEFAULT_PROXY, proxy);
Logs.v("当前网络类型为cm_cu_wap,设置代理10.0.0.172访问www");
}
break;
}
return newInstance;
}
private static ClientConnectionManager getClientConnectionManager() {
SchemeRegistry registry = new SchemeRegistry();
registry.register(new Scheme("http", 80, PlainSocketFactory.getSocketFactory()));
registry.register(new Scheme("https", 443, SSLSocketFactory.getSocketFactory()));
ThreadSafeClientConnManager cm = new ThreadSafeClientConnManager(registry);
cm.setMaxTotal(2000);
cm.setDefaultMaxPerRoute(2000);
return cm;
}
public static final HttpClient theThreadSafeHttpClient() {
SchemeRegistry registry = new SchemeRegistry();
registry.register(new Scheme("http", 80, PlainSocketFactory.getSocketFactory()));
registry.register(new Scheme("https", 443, SSLSocketFactory.getSocketFactory()));
ClientConnectionManager connectionManager = new ThreadSafeClientConnManager(registry);
HttpParams params = new BasicHttpParams();
HttpConnectionParams.setConnectionTimeout(params, DEFAULT_TIMEOUT);
HttpClient client = new DefaultHttpClient(connectionManager, params);
return client;
}
public TrustedSocketFactory(String host, boolean secure)
throws NoSuchAlgorithmException, KeyManagementException {
SSLContext sslContext = SSLContext.getInstance("TLS");
sslContext.init(
null, new TrustManager[] {TrustManagerFactory.get(host, secure)}, new SecureRandom());
mSocketFactory = sslContext.getSocketFactory();
mSchemeSocketFactory = org.apache.http.conn.ssl.SSLSocketFactory.getSocketFactory();
mSchemeSocketFactory.setHostnameVerifier(
org.apache.http.conn.ssl.SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
}
private static SocketFactory createSocketFactory(boolean allowInvalidCerts) {
SocketFactory sslSocketFactory;
if (allowInvalidCerts) {
sslSocketFactory = new WeaveSSLSocketFactory();
} else {
sslSocketFactory = SSLSocketFactory.getSocketFactory();
((SSLSocketFactory) sslSocketFactory).setHostnameVerifier(new WeaveHostnameVerifier());
}
return sslSocketFactory;
}
/**
* Returns a SSlSocketFactory which trusts all certificates
*
* @return SSLSocketFactory
*/
public static SSLSocketFactory getFixedSocketFactory() {
SSLSocketFactory socketFactory;
try {
socketFactory = new MySSLSocketFactory(getKeystore());
socketFactory.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
} catch (Throwable t) {
t.printStackTrace();
socketFactory = SSLSocketFactory.getSocketFactory();
}
return socketFactory;
}
public Http(Context context) {
BasicHttpParams httpParams = new BasicHttpParams();
ConnManagerParams.setTimeout(httpParams, socketTimeout);
ConnManagerParams.setMaxConnectionsPerRoute(httpParams, new ConnPerRouteBean(maxConnections));
ConnManagerParams.setMaxTotalConnections(httpParams, 10);
HttpConnectionParams.setSoTimeout(httpParams, socketTimeout);
HttpConnectionParams.setConnectionTimeout(httpParams, socketTimeout);
HttpConnectionParams.setTcpNoDelay(httpParams, true);
HttpConnectionParams.setSocketBufferSize(httpParams, DEFAULT_SOCKET_BUFFER_SIZE);
HttpProtocolParams.setVersion(httpParams, HttpVersion.HTTP_1_1);
SchemeRegistry schemeRegistry = new SchemeRegistry();
schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
schemeRegistry.register(new Scheme("https", SSLSocketFactory.getSocketFactory(), 443));
ThreadSafeClientConnManager cm = new ThreadSafeClientConnManager(httpParams, schemeRegistry);
httpContext = new SyncBasicHttpContext(new BasicHttpContext());
httpClient = new DefaultHttpClient(cm, httpParams);
httpClient.addRequestInterceptor(
new HttpRequestInterceptor() {
public void process(HttpRequest request, HttpContext context) {
if (!request.containsHeader(HEADER_ACCEPT_ENCODING)) {
request.addHeader(HEADER_ACCEPT_ENCODING, ENCODING_GZIP);
}
for (String header : clientHeaderMap.keySet()) {
request.addHeader(header, clientHeaderMap.get(header));
}
}
});
httpClient.addResponseInterceptor(
new HttpResponseInterceptor() {
public void process(HttpResponse response, HttpContext context) {
final HttpEntity entity = response.getEntity();
if (entity == null) {
return;
}
final Header encoding = entity.getContentEncoding();
if (encoding != null) {
for (HeaderElement element : encoding.getElements()) {
if (element.getName().equalsIgnoreCase(ENCODING_GZIP)) {
response.setEntity(new InflatingEntity(response.getEntity()));
break;
}
}
}
}
});
clientHeaderMap = new HashMap<String, String>();
}
private HttpClient createHttpClient() {
HttpParams params = new BasicHttpParams();
HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);
HttpProtocolParams.setContentCharset(params, HTTP.DEFAULT_CONTENT_CHARSET);
HttpProtocolParams.setUseExpectContinue(params, true);
SchemeRegistry schReg = new SchemeRegistry();
schReg.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
schReg.register(new Scheme("https", SSLSocketFactory.getSocketFactory(), 443));
ClientConnectionManager conMgr = new ThreadSafeClientConnManager(params, schReg);
return new DefaultHttpClient(conMgr, params);
}
/**
* Main constructor class for setting up the client that the specific Places/Context clients
* extend from.
*/
protected AbstractSimpleGeoClient() {
HttpParams params = new BasicHttpParams();
HttpProtocolParams.setUseExpectContinue(params, false);
SchemeRegistry schemeRegistry = new SchemeRegistry();
schemeRegistry.register(new Scheme("https", PORT, SSLSocketFactory.getSocketFactory()));
ThreadSafeClientConnManager connManager = new ThreadSafeClientConnManager(schemeRegistry);
this.httpClient = new OAuthHttpClient(connManager, params);
this.threadExecutor = new RequestThreadPoolExecutor("SimpleGeoClient");
endpoints.put("features", "1.0/features/%s.json");
endpoints.put("annotations", "1.0/features/%s/annotations.json");
}
@Override
public void onCreate() {
super.onCreate();
// MobclickAgent.openActivityDurationTrack(false);
SSLSocketFactory.getSocketFactory().setHostnameVerifier(new AllowAllHostnameVerifier());
mContext = this;
initDatabase();
initImageLoader();
initAppConfig();
}
public static org.apache.http.conn.ssl.SSLSocketFactory getFixedSocketFactory()
{
try
{
MySSLSocketFactory localMySSLSocketFactory = new MySSLSocketFactory(getKeystore());
localMySSLSocketFactory.setHostnameVerifier(org.apache.http.conn.ssl.SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
return localMySSLSocketFactory;
}
catch (Throwable localThrowable)
{
localThrowable.printStackTrace();
}
return org.apache.http.conn.ssl.SSLSocketFactory.getSocketFactory();
}
public void init() {
if (inited) {
return;
}
// init thread pool
executor =
new NimTaskExecutor(
"NIM_HTTP_TASK_EXECUTOR", new NimTaskExecutor.Config(1, 3, 10 * 1000, true));
// init HttpClient supporting multi thread access
HttpParams httpParams = new BasicHttpParams();
// 设置最大连接数
ConnManagerParams.setMaxTotalConnections(httpParams, MAX_CONNECTIONS);
// 设置获取连接的最大等待时间
ConnManagerParams.setTimeout(httpParams, WAIT_TIMEOUT);
// 设置每个路由最大连接数
ConnManagerParams.setMaxConnectionsPerRoute(
httpParams, new ConnPerRouteBean(MAX_ROUTE_CONNECTIONS));
// 设置连接超时时间
HttpConnectionParams.setConnectionTimeout(httpParams, CONNECT_TIMEOUT);
// 设置读取超时时间
HttpConnectionParams.setSoTimeout(httpParams, READ_TIMEOUT);
SchemeRegistry registry = new SchemeRegistry();
registry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
registry.register(new Scheme("https", SSLSocketFactory.getSocketFactory(), 443));
SSLSocketFactory.getSocketFactory().setHostnameVerifier(new AllowAllHostnameVerifier());
connManager = new ThreadSafeClientConnManager(httpParams, registry);
client = new DefaultHttpClient(connManager, httpParams);
uiHandler = new Handler(DemoCache.getContext().getMainLooper());
inited = true;
}
/**
* XMLRPCClient constructor. Creates new instance based on server URI (Code contributed by sgayda2
* from issue #17, and by erickok from ticket #10)
*
* @param XMLRPC server URI
*/
public XMLRPCClient(URI uri) {
SchemeRegistry registry = new SchemeRegistry();
registry.register(new Scheme("http", new PlainSocketFactory(), 80));
registry.register(new Scheme("https", SSLSocketFactory.getSocketFactory(), 443));
postMethod = new HttpPost(uri);
postMethod.addHeader("Content-Type", "text/xml");
// WARNING
// I had to disable "Expect: 100-Continue" header since I had
// two second delay between sending http POST request and POST body
httpParams = postMethod.getParams();
HttpProtocolParams.setUseExpectContinue(httpParams, false);
this.client =
new DefaultHttpClient(new ThreadSafeClientConnManager(httpParams, registry), httpParams);
}
public void setPbapiHttpClient(final HttpClient httpClient) {
HttpParams params = httpClient.getParams();
// if there is proxy then set it.
if (proxyHost != null) {
HttpHost proxy = new HttpHost(proxyHost, proxyPort, "http");
params.setParameter(ConnRoutePNames.DEFAULT_PROXY, proxy);
}
SchemeRegistry schemeRegistry = new SchemeRegistry();
schemeRegistry.register(new Scheme("http", HTTP, PlainSocketFactory.getSocketFactory()));
schemeRegistry.register(new Scheme("https", HTTPS, SSLSocketFactory.getSocketFactory()));
ClientConnectionManager connectionManager = new ThreadSafeClientConnManager(schemeRegistry);
DefaultHttpClient httpClientWithRetryHandler = new DefaultHttpClient(connectionManager, params);
httpClientWithRetryHandler.setHttpRequestRetryHandler(
new HttpRequestRetryHandler() {
public boolean retryRequest(
IOException exception, int executionCount, HttpContext context) {
if (executionCount >= MAX_EXECUTION_COUNT) {
return false;
}
if (exception instanceof NoHttpResponseException
|| exception instanceof SocketTimeoutException) {
if (executionCount < MIN_EXECUTION_COUNT) {
LOG.warn(
"pbapiHttpClient encountered exception '"
+ exception.getMessage()
+ "' retrying request, retryCount="
+ executionCount);
} else {
LOG.error(
"pbapiHttpClient encountered exception '"
+ exception.getMessage()
+ "' retrying request, retryCount="
+ executionCount);
}
return true;
}
return false;
}
});
this.placesAPIHttpClient = httpClientWithRetryHandler;
}
private YammerHttpClient() {
SchemeRegistry schemeRegistry = new SchemeRegistry();
schemeRegistry.register(
new Scheme(HttpHost.DEFAULT_SCHEME_NAME, 80, PlainSocketFactory.getSocketFactory()));
schemeRegistry.register(new Scheme("https", 443, SSLSocketFactory.getSocketFactory()));
DefaultHttpClient defaultHttpClient =
new DefaultHttpClient(new ThreadSafeClientConnManager(schemeRegistry));
HttpParams params = defaultHttpClient.getParams();
HttpConnectionParams.setSoTimeout(params, 5000);
HttpConnectionParams.setConnectionTimeout(params, 5000);
HttpConnectionParams.setTcpNoDelay(params, true);
HttpProtocolParams.setContentCharset(params, HTTP.UTF_8);
HttpProtocolParams.setHttpElementCharset(params, HTTP.UTF_8);
HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);
HttpClientParams.setRedirecting(params, false);
httpClient = defaultHttpClient;
}
/** Construct a downloader for a certain repository as a certain user. */
public Downloader(String host, int port, String context, String user, String pass)
throws IOException {
m_fedoraUrlStart =
Administrator.getProtocol() + "://" + host + ":" + port + "/" + context + "/" + "get/";
m_authScope = new AuthScope(host, AuthScope.ANY_PORT, AuthScope.ANY_REALM);
m_creds = new UsernamePasswordCredentials(user, pass);
if (Administrator.getProtocol().equalsIgnoreCase("https")) {
m_cManager
.getSchemeRegistry()
.register(new Scheme("https", port, SSLSocketFactory.getSocketFactory()));
} else {
m_cManager
.getSchemeRegistry()
.register(
new Scheme(Administrator.getProtocol(), port, PlainSocketFactory.getSocketFactory()));
}
}
private HttpUtils() {
SchemeRegistry reg = new SchemeRegistry();
// sslSocFactory.setHostnameVerifier(SSLSocketFactory.BROWSER_COMPATIBLE_HOSTNAME_VERIFIER);
reg.register(new Scheme("https", SSLSocketFactory.getSocketFactory(), 443));
reg.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
params_ = new BasicHttpParams();
HttpConnectionParams.setConnectionTimeout(params_, 5000);
HttpConnectionParams.setSoTimeout(params_, 3000);
params_.setParameter(ConnManagerPNames.MAX_TOTAL_CONNECTIONS, 30);
params_.setParameter(ConnManagerPNames.MAX_CONNECTIONS_PER_ROUTE, new ConnPerRouteBean(30));
params_.setParameter(HttpProtocolParams.USE_EXPECT_CONTINUE, false);
// HttpProtocolParams.setVersion(params_, HttpVersion.HTTP_1_1);
ThreadSafeClientConnManager connMgr = new ThreadSafeClientConnManager(params_, reg);
client_ = new DefaultHttpClient(connMgr, params_);
// context_ = new BasicHttpContext();
}
/**
* Create a new instance of the HttpComponentsHttpInvokerRequestExecutor with a default {@link
* HttpClient} that uses a default {@code
* org.apache.http.impl.conn.PoolingClientConnectionManager}.
*/
public HttpComponentsHttpInvokerRequestExecutor() {
org.apache.http.conn.scheme.SchemeRegistry schemeRegistry =
new org.apache.http.conn.scheme.SchemeRegistry();
schemeRegistry.register(
new org.apache.http.conn.scheme.Scheme(
"http", 80, org.apache.http.conn.scheme.PlainSocketFactory.getSocketFactory()));
schemeRegistry.register(
new org.apache.http.conn.scheme.Scheme(
"https", 443, org.apache.http.conn.ssl.SSLSocketFactory.getSocketFactory()));
org.apache.http.impl.conn.PoolingClientConnectionManager connectionManager =
new org.apache.http.impl.conn.PoolingClientConnectionManager(schemeRegistry);
connectionManager.setMaxTotal(DEFAULT_MAX_TOTAL_CONNECTIONS);
connectionManager.setDefaultMaxPerRoute(DEFAULT_MAX_CONNECTIONS_PER_ROUTE);
this.httpClient = new org.apache.http.impl.client.DefaultHttpClient(connectionManager);
setReadTimeout(DEFAULT_READ_TIMEOUT_MILLISECONDS);
}
/**
* Create a thread-safe client. This client does not do redirecting, to allow us to capture
* correct "error" codes.
*
* @return HttpClient
*/
public static final DefaultHttpClient createHttpClient(Context mContext) {
// Sets up the http part of the service.
final SchemeRegistry supportedSchemes = new SchemeRegistry();
// Register the "http" protocol scheme, it is required
// by the default operator to look up socket factories.
final SocketFactory sf = PlainSocketFactory.getSocketFactory();
supportedSchemes.register(new Scheme("http", sf, 80));
supportedSchemes.register(new Scheme("https", SSLSocketFactory.getSocketFactory(), 443));
// Set some client http client parameter defaults.
final HttpParams httpParams = createHttpParams(mContext);
HttpClientParams.setRedirecting(httpParams, false);
final ClientConnectionManager ccm =
new ThreadSafeClientConnManager(httpParams, supportedSchemes);
return new DefaultHttpClient(ccm, httpParams);
}
