package com.ichances.fashionweek.util;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.net.Socket;
import java.net.URI;
import java.net.UnknownHostException;
import java.nio.charset.Charset;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.UnrecoverableKeyException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.Map;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import org.apache.http.HttpEntity;
import org.apache.http.HttpHost;
import org.apache.http.HttpResponse;
import org.apache.http.HttpVersion;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpUriRequest;
import org.apache.http.client.utils.URIUtils;
import org.apache.http.conn.ClientConnectionManager;
import org.apache.http.conn.params.ConnRouteParams;
import org.apache.http.conn.scheme.PlainSocketFactory;
import org.apache.http.conn.scheme.Scheme;
import org.apache.http.conn.scheme.SchemeRegistry;
import org.apache.http.conn.ssl.SSLSocketFactory;
import org.apache.http.entity.StringEntity;
import org.apache.http.entity.mime.FormBodyPart;
import org.apache.http.entity.mime.MultipartEntity;
import org.apache.http.entity.mime.content.FileBody;
import org.apache.http.entity.mime.content.StringBody;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.impl.conn.tsccm.ThreadSafeClientConnManager;
import org.apache.http.params.BasicHttpParams;
import org.apache.http.params.HttpConnectionParams;
import org.apache.http.params.HttpParams;
import org.apache.http.params.HttpProtocolParams;
import org.apache.http.protocol.HTTP;
import org.apache.http.util.EntityUtils;
import android.content.Context;
import android.database.Cursor;
import android.net.Uri;
import android.net.wifi.WifiManager;
/**
* 腾讯微博工具，分享文字、图片、图片url
*
*/
public class TecentUtil {
private static final int CONNECTION_TIMEOUT = 50000;
private static final int SOCKET_TIMEOUT = 200000;
/**
* 发布微博文字或者带图片URL的微博
*
* @param url
* 连接的URL
* @param queryString
* 请求参数串，包含内容：format、content、oauth_consumer_key、access_token、
* openid
* 、clientip、oauth_version、scope，若含图片URL，添加字段pic_url，注意，需要将Url中的
* :转为'%3A'，/转为'%2F'
* @return 服务器返回的信息
* @throws Exception
*/
public static String postContent(Context context, String url,
String queryString) throws Exception {
String responseData = null;
HttpClient httpClient = getNewHttpClient(context);
URI tmpUri = new URI(url);
URI uri = URIUtils.createURI(tmpUri.getScheme(), tmpUri.getHost(),
tmpUri.getPort(), tmpUri.getPath(), queryString, null);
HttpPost httpPost = new HttpPost(uri);
httpPost.getParams().setParameter("http.socket.timeout",
CONNECTION_TIMEOUT);
if (queryString != null && !queryString.equals("")) {
StringEntity reqEntity = new StringEntity(queryString);
// 设置类型
reqEntity.setContentType("application/x-www-form-urlencoded");
// 设置请求的数据
httpPost.setEntity(reqEntity);
}
try {
HttpResponse response = httpClient.execute(httpPost);
responseData = EntityUtils.toString(response.getEntity());
} catch (Exception e) {
e.printStackTrace();
} finally {
httpPost.abort();
}
return responseData;
}
/**
* 发布一条带图片的微博
*
* @param context
* @param url
* @param params
* 请求参数串，包含内容：format、content、oauth_consumer_key、access_token、
* openid 、clientip、oauth_version、scope
* @param filePath
* 本地图片的绝对路径
* @return
*/
public static String upLoadVaule(Context context, String url,
Map<String, Object> params, String filePath) {
HttpClient client = getNewHttpClient(context);
HttpUriRequest request = null;
HttpPost post = new HttpPost(url);
MultipartEntity mpEntity = new MultipartEntity();
StringBody stringBody = null;
FileBody fileBody;
FormBodyPart fbp;
for (String key : params.keySet()) {
try {
stringBody = new StringBody(params.get(key).toString(),
Charset.forName("UTF-8"));
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
fbp = new FormBodyPart(key, stringBody);
mpEntity.addPart(fbp);
}
fileBody = new FileBody(new File(filePath), "application/octet-stream");
fbp = new FormBodyPart("pic", fileBody);
mpEntity.addPart(fbp);
post.setEntity(mpEntity);
request = post;
HttpResponse response = null;
try {
response = client.execute(request);
} catch (ClientProtocolException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
// StatusLine status = response.getStatusLine();
// int statusCode = status.getStatusCode();
HttpEntity entity = response.getEntity();
InputStream inputStream = null;
try {
inputStream = entity.getContent();
} catch (IllegalStateException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
ByteArrayOutputStream content = new ByteArrayOutputStream();
int readBytes = 0;
byte[] sBuffer = new byte[512];
try {
while ((readBytes = inputStream.read(sBuffer)) != -1) {
content.write(sBuffer, 0, readBytes);
}
} catch (IOException e) {
e.printStackTrace();
}
return new String(content.toByteArray());
}
private static HttpClient getNewHttpClient(Context context) {
try {
KeyStore trustStore = KeyStore.getInstance(KeyStore
.getDefaultType());
trustStore.load(null, null);
SSLSocketFactory sf = new MySSLSocketFactory(trustStore);
sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
HttpParams params = new BasicHttpParams();
HttpConnectionParams.setConnectionTimeout(params, 10000);
HttpConnectionParams.setSoTimeout(params, 10000);
HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);
HttpProtocolParams.setContentCharset(params, HTTP.UTF_8);
SchemeRegistry registry = new SchemeRegistry();
registry.register(new Scheme("http", PlainSocketFactory
.getSocketFactory(), 80));
registry.register(new Scheme("https", sf, 443));
ClientConnectionManager ccm = new ThreadSafeClientConnManager(
params, registry);
// Set the default socket timeout (SO_TIMEOUT) // in
// milliseconds which is the timeout for waiting for data.
HttpConnectionParams.setConnectionTimeout(params,
CONNECTION_TIMEOUT);
HttpConnectionParams.setSoTimeout(params, SOCKET_TIMEOUT);
HttpClient client = new DefaultHttpClient(ccm, params);
WifiManager wifiManager = (WifiManager) context
.getSystemService(Context.WIFI_SERVICE);
if (!wifiManager.isWifiEnabled()) {
// 获取当前正在使用的APN接入点
Uri uri = Uri.parse("content://telephony/carriers/preferapn");
Cursor mCursor = context.getContentResolver().query(uri, null,
null, null, null);
if (mCursor != null && mCursor.moveToFirst()) {
// 游标移至第一条记录，当然也只有一条
String proxyStr = mCursor.getString(mCursor
.getColumnIndex("proxy"));
if (proxyStr != null && proxyStr.trim().length() > 0) {
HttpHost proxy = new HttpHost(proxyStr, 80);
client.getParams().setParameter(
ConnRouteParams.DEFAULT_PROXY, proxy);
}
mCursor.close();
}
}
return client;
} catch (Exception e) {
return new DefaultHttpClient();
}
}
public static class MySSLSocketFactory extends SSLSocketFactory {
SSLContext sslContext = SSLContext.getInstance("TLS");
public MySSLSocketFactory(KeyStore truststore)
throws NoSuchAlgorithmException, KeyManagementException,
KeyStoreException, UnrecoverableKeyException {
super(truststore);
TrustManager tm = new X509TrustManager() {
public void checkClientTrusted(X509Certificate[] chain,
String authType) throws CertificateException {
}
public void checkServerTrusted(X509Certificate[] chain,
String authType) throws CertificateException {
}
public X509Certificate[] getAcceptedIssuers() {
return null;
}
};
sslContext.init(null, new TrustManager[] { tm }, 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();
}
}
}
