xutils框架是如今使用比較廣泛的android開源框架，我對其也情有獨鍾，對於框架模塊，我想大家都很熟悉了，就不多說了。我今天主要主要說下xutils2.6中如何爲http請求設置cookie和session，當時這個問題糾結了很久，試了多次，問了不少人，上網搜索，結果越來越模糊，最終通過認真閱讀源代碼，終於清楚如何使用了，現在和大家分享一下自己的心得，也希望大家對開源框架的學習要認真閱讀源代碼。
不多說了，大家看示例。
程序設計到三個類，
1.MyApplication（擴展應用）定義保存的Cookie和會話的全局變量
2.LoginActivity演示獲得的cookie和session
3.GetDataActivity演示設置的cookie和session
import com.lidroid.xutils.util.PreferencesCookieStore;
import android.app.Application;
public class MyApplication extends Application{
/**
* 用PreferencesCookieStore 持久化cookie到本地
* 類的定義：public class PreferencesCookieStore implements CookieStore
* 其內部用SharedPreferences保存，操作內部已封裝
* 位置：com.lidroid.xutils.util.PreferencesCookieStore;
*
* 特別注意：PreferencesCookieStore 這個類在xutils 2.6中才出現，以前的版本沒有
* xutils 3.x 版本中也沒有這個類
* 在xutils 2.6 以前版本要麼自己參照PreferencesCookieStore源碼，保存cookie到本地
* 或者自己用SharedPreferences保存sessionid 到本地,sessionid就是一個字符串，用
* SharedPreferences保存很簡單，就不介紹了
*
* 注：sessionid 實際是保存在cookie中
* 向服務器可以提交cookie 或 sessionid
* 提交cookie :調用方法 public HttpUtils configCookieStore(CookieStore cookieStore);
* 提交sessionid ： RequestParams public void addHeader(String name, String value);
* 或setHeader(String name, String value);
*/
public static PreferencesCookieStore presCookieStore;
public static String jsessionid = ""; //保存sessionid
public void onCreate() {
/*
* 程序啓動，調用這個構造函數
* 在構造函數中 PreferencesCookieStore內部從本地
* 取出cookie,保存在PreferencesCookieStore 中的隊列中
* 如果本地沒有，PreferencesCookieStore public List<Cookie> getCookies();
* 返回的 List<Cookie> 長度爲0
*
*/
presCookieStore = new PreferencesCookieStore(getApplicationContext());
}
}
import java.util.List;
import org.apache.http.client.CookieStore;
import org.apache.http.cookie.Cookie;
import org.apache.http.impl.client.DefaultHttpClient;
import com.lidroid.xutils.HttpUtils;
import com.lidroid.xutils.exception.HttpException;
import com.lidroid.xutils.http.RequestParams;
import com.lidroid.xutils.http.ResponseInfo;
import com.lidroid.xutils.http.callback.RequestCallBack;
import com.lidroid.xutils.http.client.HttpRequest.HttpMethod;
public class LoginActivity {
/**
* 登陸 後獲得cookie sessionid
* 這兒只是演示如何獲得cookie和seesionid
* 因此 url,RequestParams 直接用null,大家注意
*
*/
public void login(){
final HttpUtils http = new HttpUtils();
String url = null;
RequestParams params = null;
http.send(HttpMethod.POST, url,params, new RequestCallBack<String>() {
@Override
public void onFailure(HttpException arg0, String arg1) {
}
@Override
public void onSuccess(ResponseInfo<String> arg0) {
/*
* 得到cookie seesionid 並持久化到本地的核心代碼
*/
DefaultHttpClient defaultHttpClient = (DefaultHttpClient) http.getHttpClient();
CookieStore cookieStore = defaultHttpClient.getCookieStore();
List<Cookie> cookies = cookieStore.getCookies();
for (Cookie cookie : cookies) {
if ("JSESSIONID".equals(cookie.getName())) {
MyApplication.jsessionid = cookie.getValue(); //得到sessionid
}
MyApplication.presCookieStore.addCookie(cookie); //將cookie保存在本地
}
}
});
}
}import com.lidroid.xutils.HttpUtils;
import com.lidroid.xutils.exception.HttpException;
import com.lidroid.xutils.http.RequestParams;
import com.lidroid.xutils.http.ResponseInfo;
import com.lidroid.xutils.http.callback.RequestCallBack;
import com.lidroid.xutils.http.client.HttpRequest.HttpMethod;
/**
* 從服務器獲取數據前 添加cookie
* 或sessionid
*
* @author Administrator
*
*/
public class GetDataActivity {
public void getData() {
final HttpUtils http = new HttpUtils();
String url = null;
/*
* get無參請求添加cookie
* get 含參請求可以添加cookie或session
* post請求可以添加cookie或session
*/
http.configCookieStore(MyApplication.presCookieStore);
http.send(HttpMethod.GET, url, new RequestCallBack<String>() {
@Override
public void onFailure(HttpException arg0, String arg1) {}
@Override
public void onSuccess(ResponseInfo<String> arg0) {}
});
/*
* seesionid字段在不同服務器開發語言中不同
* java中“JSESSIONID”，php中“PSESSIONID” 其他請自己查閱資料
* 這兒用java示例
*
* setHeader 和addHeader的區別：
* setHeader 未設置時，添加；已設置，重新賦值
* addHeader 未設置時，添加；已設置，仍保持以前的值不變
*/
RequestParams params = new RequestParams();
params.setHeader("Cookie", "JSESSIONID="+MyApplication.jsessionid); //設置頭信息
http.send(HttpMethod.GET, url, new RequestCallBack<String>() {
@Override
public void onFailure(HttpException arg0, String arg1) {}
@Override
public void onSuccess(ResponseInfo<String> arg0) {}
});
}
}如果存在不足，請大家多多指教，共同進步！
參考Xutils2.6源代碼
1.HttpUtils
package com.lidroid.xutils;
import android.text.TextUtils;
import com.lidroid.xutils.exception.HttpException;
import com.lidroid.xutils.http.*;
import com.lidroid.xutils.http.callback.HttpRedirectHandler;
import com.lidroid.xutils.http.callback.RequestCallBack;
import com.lidroid.xutils.http.client.DefaultSSLSocketFactory;
import com.lidroid.xutils.http.client.HttpRequest;
import com.lidroid.xutils.http.client.RetryHandler;
import com.lidroid.xutils.http.client.entity.GZipDecompressingEntity;
import com.lidroid.xutils.task.PriorityExecutor;
import com.lidroid.xutils.util.OtherUtils;
import org.apache.http.*;
import org.apache.http.client.CookieStore;
import org.apache.http.client.HttpClient;
import org.apache.http.client.protocol.ClientContext;
import org.apache.http.conn.params.ConnManagerParams;
import org.apache.http.conn.params.ConnPerRouteBean;
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.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.BasicHttpContext;
import org.apache.http.protocol.HTTP;
import org.apache.http.protocol.HttpContext;
import java.io.File;
import java.io.IOException;
public class HttpUtils {
public final static HttpCache sHttpCache = new HttpCache();
private final DefaultHttpClient httpClient;
private final HttpContext httpContext = new BasicHttpContext();
private HttpRedirectHandler httpRedirectHandler;
public HttpUtils() {
this(HttpUtils.DEFAULT_CONN_TIMEOUT, null);
}
public HttpUtils(int connTimeout) {
this(connTimeout, null);
}
public HttpUtils(String userAgent) {
this(HttpUtils.DEFAULT_CONN_TIMEOUT, userAgent);
}
public HttpUtils(int connTimeout, String userAgent) {
HttpParams params = new BasicHttpParams();
ConnManagerParams.setTimeout(params, connTimeout);
HttpConnectionParams.setSoTimeout(params, connTimeout);
HttpConnectionParams.setConnectionTimeout(params, connTimeout);
if (TextUtils.isEmpty(userAgent)) {
userAgent = OtherUtils.getUserAgent(null);
}
HttpProtocolParams.setUserAgent(params, userAgent);
ConnManagerParams.setMaxConnectionsPerRoute(params, new ConnPerRouteBean(10));
ConnManagerParams.setMaxTotalConnections(params, 10);
HttpConnectionParams.setTcpNoDelay(params, true);
HttpConnectionParams.setSocketBufferSize(params, 1024 * 8);
HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);
SchemeRegistry schemeRegistry = new SchemeRegistry();
schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
schemeRegistry.register(new Scheme("https", DefaultSSLSocketFactory.getSocketFactory(), 443));
httpClient = new DefaultHttpClient(new ThreadSafeClientConnManager(params, schemeRegistry), params);
httpClient.setHttpRequestRetryHandler(new RetryHandler(DEFAULT_RETRY_TIMES));
httpClient.addRequestInterceptor(new HttpRequestInterceptor() {
@Override
public void process(org.apache.http.HttpRequest httpRequest, HttpContext httpContext) throws org.apache.http.HttpException, IOException {
if (!httpRequest.containsHeader(HEADER_ACCEPT_ENCODING)) {
httpRequest.addHeader(HEADER_ACCEPT_ENCODING, ENCODING_GZIP);
}
}
});
httpClient.addResponseInterceptor(new HttpResponseInterceptor() {
@Override
public void process(HttpResponse response, HttpContext httpContext) throws org.apache.http.HttpException, IOException {
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("gzip")) {
response.setEntity(new GZipDecompressingEntity(response.getEntity()));
return;
}
}
}
}
});
}
// ************************************ default settings & fields ****************************
private String responseTextCharset = HTTP.UTF_8;
private long currentRequestExpiry = HttpCache.getDefaultExpiryTime();
private final static int DEFAULT_CONN_TIMEOUT = 1000 * 15; // 15s
private final static int DEFAULT_RETRY_TIMES = 3;
private static final String HEADER_ACCEPT_ENCODING = "Accept-Encoding";
private static final String ENCODING_GZIP = "gzip";
private final static int DEFAULT_POOL_SIZE = 3;
private final static PriorityExecutor EXECUTOR = new PriorityExecutor(DEFAULT_POOL_SIZE);
public HttpClient getHttpClient() {
return this.httpClient;
}
// ***************************************** config *******************************************
public HttpUtils configResponseTextCharset(String charSet) {
if (!TextUtils.isEmpty(charSet)) {
this.responseTextCharset = charSet;
}
return this;
}
public HttpUtils configHttpRedirectHandler(HttpRedirectHandler httpRedirectHandler) {
this.httpRedirectHandler = httpRedirectHandler;
return this;
}
public HttpUtils configHttpCacheSize(int httpCacheSize) {
sHttpCache.setCacheSize(httpCacheSize);
return this;
}
public HttpUtils configDefaultHttpCacheExpiry(long defaultExpiry) {
HttpCache.setDefaultExpiryTime(defaultExpiry);
currentRequestExpiry = HttpCache.getDefaultExpiryTime();
return this;
}
public HttpUtils configCurrentHttpCacheExpiry(long currRequestExpiry) {
this.currentRequestExpiry = currRequestExpiry;
return this;
}
public HttpUtils configCookieStore(CookieStore cookieStore) {
httpContext.setAttribute(ClientContext.COOKIE_STORE, cookieStore);
return this;
}
public HttpUtils configUserAgent(String userAgent) {
HttpProtocolParams.setUserAgent(this.httpClient.getParams(), userAgent);
return this;
}
public HttpUtils configTimeout(int timeout) {
final HttpParams httpParams = this.httpClient.getParams();
ConnManagerParams.setTimeout(httpParams, timeout);
HttpConnectionParams.setConnectionTimeout(httpParams, timeout);
return this;
}
public HttpUtils configSoTimeout(int timeout) {
final HttpParams httpParams = this.httpClient.getParams();
HttpConnectionParams.setSoTimeout(httpParams, timeout);
return this;
}
public HttpUtils configRegisterScheme(Scheme scheme) {
this.httpClient.getConnectionManager().getSchemeRegistry().register(scheme);
return this;
}
public HttpUtils configSSLSocketFactory(SSLSocketFactory sslSocketFactory) {
Scheme scheme = new Scheme("https", sslSocketFactory, 443);
this.httpClient.getConnectionManager().getSchemeRegistry().register(scheme);
return this;
}
public HttpUtils configRequestRetryCount(int count) {
this.httpClient.setHttpRequestRetryHandler(new RetryHandler(count));
return this;
}
public HttpUtils configRequestThreadPoolSize(int threadPoolSize) {
HttpUtils.EXECUTOR.setPoolSize(threadPoolSize);
return this;
}
// ***************************************** send request *******************************************
public <T> HttpHandler<T> send(HttpRequest.HttpMethod method, String url,
RequestCallBack<T> callBack) {
return send(method, url, null, callBack);
}
public <T> HttpHandler<T> send(HttpRequest.HttpMethod method, String url, RequestParams params,
RequestCallBack<T> callBack) {
if (url == null) throw new IllegalArgumentException("url may not be null");
HttpRequest request = new HttpRequest(method, url);
return sendRequest(request, params, callBack);
}
public ResponseStream sendSync(HttpRequest.HttpMethod method, String url) throws HttpException {
return sendSync(method, url, null);
}
public ResponseStream sendSync(HttpRequest.HttpMethod method, String url, RequestParams params) throws HttpException {
if (url == null) throw new IllegalArgumentException("url may not be null");
HttpRequest request = new HttpRequest(method, url);
return sendSyncRequest(request, params);
}
// ***************************************** download *******************************************
public HttpHandler<File> download(String url, String target,
RequestCallBack<File> callback) {
return download(HttpRequest.HttpMethod.GET, url, target, null, false, false, callback);
}
public HttpHandler<File> download(String url, String target,
boolean autoResume, RequestCallBack<File> callback) {
return download(HttpRequest.HttpMethod.GET, url, target, null, autoResume, false, callback);
}
public HttpHandler<File> download(String url, String target,
boolean autoResume, boolean autoRename, RequestCallBack<File> callback) {
return download(HttpRequest.HttpMethod.GET, url, target, null, autoResume, autoRename, callback);
}
public HttpHandler<File> download(String url, String target,
RequestParams params, RequestCallBack<File> callback) {
return download(HttpRequest.HttpMethod.GET, url, target, params, false, false, callback);
}
public HttpHandler<File> download(String url, String target,
RequestParams params, boolean autoResume, RequestCallBack<File> callback) {
return download(HttpRequest.HttpMethod.GET, url, target, params, autoResume, false, callback);
}
public HttpHandler<File> download(String url, String target,
RequestParams params, boolean autoResume, boolean autoRename, RequestCallBack<File> callback) {
return download(HttpRequest.HttpMethod.GET, url, target, params, autoResume, autoRename, callback);
}
public HttpHandler<File> download(HttpRequest.HttpMethod method, String url, String target,
RequestParams params, RequestCallBack<File> callback) {
return download(method, url, target, params, false, false, callback);
}
public HttpHandler<File> download(HttpRequest.HttpMethod method, String url, String target,
RequestParams params, boolean autoResume, RequestCallBack<File> callback) {
return download(method, url, target, params, autoResume, false, callback);
}
public HttpHandler<File> download(HttpRequest.HttpMethod method, String url, String target,
RequestParams params, boolean autoResume, boolean autoRename, RequestCallBack<File> callback) {
if (url == null) throw new IllegalArgumentException("url may not be null");
if (target == null) throw new IllegalArgumentException("target may not be null");
HttpRequest request = new HttpRequest(method, url);
HttpHandler<File> handler = new HttpHandler<File>(httpClient, httpContext, responseTextCharset, callback);
handler.setExpiry(currentRequestExpiry);
handler.setHttpRedirectHandler(httpRedirectHandler);
if (params != null) {
request.setRequestParams(params, handler);
handler.setPriority(params.getPriority());
}
handler.executeOnExecutor(EXECUTOR, request, target, autoResume, autoRename);
return handler;
}
////////////////////////////////////////////////////////////////////////////////////////////////
private <T> HttpHandler<T> sendRequest(HttpRequest request, RequestParams params, RequestCallBack<T> callBack) {
HttpHandler<T> handler = new HttpHandler<T>(httpClient, httpContext, responseTextCharset, callBack);
handler.setExpiry(currentRequestExpiry);
handler.setHttpRedirectHandler(httpRedirectHandler);
request.setRequestParams(params, handler);
if (params != null) {
handler.setPriority(params.getPriority());
}
handler.executeOnExecutor(EXECUTOR, request);
return handler;
}
private ResponseStream sendSyncRequest(HttpRequest request, RequestParams params) throws HttpException {
SyncHttpHandler handler = new SyncHttpHandler(httpClient, httpContext, responseTextCharset);
handler.setExpiry(currentRequestExpiry);
handler.setHttpRedirectHandler(httpRedirectHandler);
request.setRequestParams(params);
return handler.sendRequest(request);
}
}2.PreferencesCookieStore
package com.lidroid.xutils.util;
import android.content.Context;
import android.content.SharedPreferences;
import android.text.TextUtils;
import org.apache.http.client.CookieStore;
import org.apache.http.cookie.Cookie;
import org.apache.http.impl.cookie.BasicClientCookie;
import java.io.*;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
/**
* A CookieStore impl, it's save cookie to SharedPreferences.
*
* @author michael yang
*/
public class PreferencesCookieStore implements CookieStore {
private static final String COOKIE_PREFS = "CookiePrefsFile";
private static final String COOKIE_NAME_STORE = "names";
private static final String COOKIE_NAME_PREFIX = "cookie_";
private final ConcurrentHashMap<String, Cookie> cookies;
private final SharedPreferences cookiePrefs;
/**
* Construct a persistent cookie store.
*/
public PreferencesCookieStore(Context context) {
cookiePrefs = context.getSharedPreferences(COOKIE_PREFS, Context.MODE_PRIVATE);
cookies = new ConcurrentHashMap<String, Cookie>();
// Load any previously stored cookies into the store
String storedCookieNames = cookiePrefs.getString(COOKIE_NAME_STORE, null);
if (storedCookieNames != null) {
String[] cookieNames = TextUtils.split(storedCookieNames, ",");
for (String name : cookieNames) {
String encodedCookie = cookiePrefs.getString(COOKIE_NAME_PREFIX + name, null);
if (encodedCookie != null) {
Cookie decodedCookie = decodeCookie(encodedCookie);
if (decodedCookie != null) {
cookies.put(name, decodedCookie);
}
}
}
// Clear out expired cookies
clearExpired(new Date());
}
}
@Override
public void addCookie(Cookie cookie) {
String name = cookie.getName();
// Save cookie into local store, or remove if expired
if (!cookie.isExpired(new Date())) {
cookies.put(name, cookie);
} else {
cookies.remove(name);
}
// Save cookie into persistent store
SharedPreferences.Editor editor = cookiePrefs.edit();
editor.putString(COOKIE_NAME_STORE, TextUtils.join(",", cookies.keySet()));
editor.putString(COOKIE_NAME_PREFIX + name, encodeCookie(new SerializableCookie(cookie)));
editor.commit();
}
@Override
public void clear() {
// Clear cookies from persistent store
SharedPreferences.Editor editor = cookiePrefs.edit();
for (String name : cookies.keySet()) {
editor.remove(COOKIE_NAME_PREFIX + name);
}
editor.remove(COOKIE_NAME_STORE);
editor.commit();
// Clear cookies from local store
cookies.clear();
}
@Override
public boolean clearExpired(Date date) {
boolean clearedAny = false;
SharedPreferences.Editor editor = cookiePrefs.edit();
for (ConcurrentHashMap.Entry<String, Cookie> entry : cookies.entrySet()) {
String name = entry.getKey();
Cookie cookie = entry.getValue();
if (cookie.getExpiryDate() == null || cookie.isExpired(date)) {
// Remove the cookie by name
cookies.remove(name);
// Clear cookies from persistent store
editor.remove(COOKIE_NAME_PREFIX + name);
// We've cleared at least one
clearedAny = true;
}
}
// Update names in persistent store
if (clearedAny) {
editor.putString(COOKIE_NAME_STORE, TextUtils.join(",", cookies.keySet()));
}
editor.commit();
return clearedAny;
}
@Override
public List<Cookie> getCookies() {
return new ArrayList<Cookie>(cookies.values());
}
public Cookie getCookie(String name) {
return cookies.get(name);
}
protected String encodeCookie(SerializableCookie cookie) {
ByteArrayOutputStream os = new ByteArrayOutputStream();
try {
ObjectOutputStream outputStream = new ObjectOutputStream(os);
outputStream.writeObject(cookie);
} catch (Throwable e) {
return null;
}
return byteArrayToHexString(os.toByteArray());
}
protected Cookie decodeCookie(String cookieStr) {
byte[] bytes = hexStringToByteArray(cookieStr);
ByteArrayInputStream is = new ByteArrayInputStream(bytes);
Cookie cookie = null;
try {
ObjectInputStream ois = new ObjectInputStream(is);
cookie = ((SerializableCookie) ois.readObject()).getCookie();
} catch (Throwable e) {
LogUtils.e(e.getMessage(), e);
}
return cookie;
}
// Using some super basic byte array <-> hex conversions so we don't have
// to rely on any large Base64 libraries. Can be overridden if you like!
protected String byteArrayToHexString(byte[] b) {
StringBuffer sb = new StringBuffer(b.length * 2);
for (byte element : b) {
int v = element & 0xff;
if (v < 16) {
sb.append('0');
}
sb.append(Integer.toHexString(v));
}
return sb.toString().toUpperCase();
}
protected byte[] hexStringToByteArray(String s) {
int len = s.length();
byte[] data = new byte[len / 2];
for (int i = 0; i < len; i += 2) {
data[i / 2] = (byte) ((Character.digit(s.charAt(i), 16) << 4) + Character.digit(s.charAt(i + 1), 16));
}
return data;
}
public class SerializableCookie implements Serializable {
private static final long serialVersionUID = 6374381828722046732L;
private transient final Cookie cookie;
private transient BasicClientCookie clientCookie;
public SerializableCookie(Cookie cookie) {
this.cookie = cookie;
}
public Cookie getCookie() {
Cookie bestCookie = cookie;
if (clientCookie != null) {
bestCookie = clientCookie;
}
return bestCookie;
}
private void writeObject(ObjectOutputStream out) throws IOException {
out.writeObject(cookie.getName());
out.writeObject(cookie.getValue());
out.writeObject(cookie.getComment());
out.writeObject(cookie.getDomain());
out.writeObject(cookie.getExpiryDate());
out.writeObject(cookie.getPath());
out.writeInt(cookie.getVersion());
out.writeBoolean(cookie.isSecure());
}
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
String name = (String) in.readObject();
String value = (String) in.readObject();
clientCookie = new BasicClientCookie(name, value);
clientCookie.setComment((String) in.readObject());
clientCookie.setDomain((String) in.readObject());
clientCookie.setExpiryDate((Date) in.readObject());
clientCookie.setPath((String) in.readObject());
clientCookie.setVersion(in.readInt());
clientCookie.setSecure(in.readBoolean());
}
}
}3.RequestParams
package com.lidroid.xutils.http;
import android.text.TextUtils;
import com.lidroid.xutils.http.client.entity.BodyParamsEntity;
import com.lidroid.xutils.http.client.multipart.HttpMultipartMode;
import com.lidroid.xutils.http.client.multipart.MultipartEntity;
import com.lidroid.xutils.http.client.multipart.content.ContentBody;
import com.lidroid.xutils.http.client.multipart.content.FileBody;
import com.lidroid.xutils.http.client.multipart.content.InputStreamBody;
import com.lidroid.xutils.http.client.multipart.content.StringBody;
import com.lidroid.xutils.util.LogUtils;
import com.lidroid.xutils.task.Priority;
import org.apache.http.Header;
import org.apache.http.HttpEntity;
import org.apache.http.NameValuePair;
import org.apache.http.message.BasicHeader;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.protocol.HTTP;
import java.io.File;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
public class RequestParams {
private String charset = HTTP.UTF_8;
private List<HeaderItem> headers;
private List<NameValuePair> queryStringParams;
private HttpEntity bodyEntity;
private List<NameValuePair> bodyParams;
private HashMap<String, ContentBody> fileParams;
private Priority priority;
public RequestParams() {
}
public RequestParams(String charset) {
if (!TextUtils.isEmpty(charset)) {
this.charset = charset;
}
}
public Priority getPriority() {
return priority;
}
public void setPriority(Priority priority) {
this.priority = priority;
}
public String getCharset() {
return charset;
}
public void setContentType(String contentType) {
this.setHeader("Content-Type", contentType);
}
/**
* Adds a header to this message. The header will be appended to the end of the list.
*
* @param header
*/
public void addHeader(Header header) {
if (this.headers == null) {
this.headers = new ArrayList<HeaderItem>();
}
this.headers.add(new HeaderItem(header));
}
/**
* Adds a header to this message. The header will be appended to the end of the list.
*
* @param name
* @param value
*/
public void addHeader(String name, String value) {
if (this.headers == null) {
this.headers = new ArrayList<HeaderItem>();
}
this.headers.add(new HeaderItem(name, value));
}
/**
* Adds all the headers to this message.
*
* @param headers
*/
public void addHeaders(List<Header> headers) {
if (this.headers == null) {
this.headers = new ArrayList<HeaderItem>();
}
for (Header header : headers) {
this.headers.add(new HeaderItem(header));
}
}
/**
* Overwrites the first header with the same name.
* The new header will be appended to the end of the list, if no header with the given name can be found.
*
* @param header
*/
public void setHeader(Header header) {
if (this.headers == null) {
this.headers = new ArrayList<HeaderItem>();
}
this.headers.add(new HeaderItem(header, true));
}
/**
* Overwrites the first header with the same name.
* The new header will be appended to the end of the list, if no header with the given name can be found.
*
* @param name
* @param value
*/
public void setHeader(String name, String value) {
if (this.headers == null) {
this.headers = new ArrayList<HeaderItem>();
}
this.headers.add(new HeaderItem(name, value, true));
}
/**
* Overwrites all the headers in the message.
*
* @param headers
*/
public void setHeaders(List<Header> headers) {
if (this.headers == null) {
this.headers = new ArrayList<HeaderItem>();
}
for (Header header : headers) {
this.headers.add(new HeaderItem(header, true));
}
}
public void addQueryStringParameter(String name, String value) {
if (queryStringParams == null) {
queryStringParams = new ArrayList<NameValuePair>();
}
queryStringParams.add(new BasicNameValuePair(name, value));
}
public void addQueryStringParameter(NameValuePair nameValuePair) {
if (queryStringParams == null) {
queryStringParams = new ArrayList<NameValuePair>();
}
queryStringParams.add(nameValuePair);
}
public void addQueryStringParameter(List<NameValuePair> nameValuePairs) {
if (queryStringParams == null) {
queryStringParams = new ArrayList<NameValuePair>();
}
if (nameValuePairs != null && nameValuePairs.size() > 0) {
for (NameValuePair pair : nameValuePairs) {
queryStringParams.add(pair);
}
}
}
public void addBodyParameter(String name, String value) {
if (bodyParams == null) {
bodyParams = new ArrayList<NameValuePair>();
}
bodyParams.add(new BasicNameValuePair(name, value));
}
public void addBodyParameter(NameValuePair nameValuePair) {
if (bodyParams == null) {
bodyParams = new ArrayList<NameValuePair>();
}
bodyParams.add(nameValuePair);
}
public void addBodyParameter(List<NameValuePair> nameValuePairs) {
if (bodyParams == null) {
bodyParams = new ArrayList<NameValuePair>();
}
if (nameValuePairs != null && nameValuePairs.size() > 0) {
for (NameValuePair pair : nameValuePairs) {
bodyParams.add(pair);
}
}
}
public void addBodyParameter(String key, File file) {
if (fileParams == null) {
fileParams = new HashMap<String, ContentBody>();
}
fileParams.put(key, new FileBody(file));
}
public void addBodyParameter(String key, File file, String mimeType) {
if (fileParams == null) {
fileParams = new HashMap<String, ContentBody>();
}
fileParams.put(key, new FileBody(file, mimeType));
}
public void addBodyParameter(String key, File file, String mimeType, String charset) {
if (fileParams == null) {
fileParams = new HashMap<String, ContentBody>();
}
fileParams.put(key, new FileBody(file, mimeType, charset));
}
public void addBodyParameter(String key, File file, String fileName, String mimeType, String charset) {
if (fileParams == null) {
fileParams = new HashMap<String, ContentBody>();
}
fileParams.put(key, new FileBody(file, fileName, mimeType, charset));
}
public void addBodyParameter(String key, InputStream stream, long length) {
if (fileParams == null) {
fileParams = new HashMap<String, ContentBody>();
}
fileParams.put(key, new InputStreamBody(stream, length));
}
public void addBodyParameter(String key, InputStream stream, long length, String fileName) {
if (fileParams == null) {
fileParams = new HashMap<String, ContentBody>();
}
fileParams.put(key, new InputStreamBody(stream, length, fileName));
}
public void addBodyParameter(String key, InputStream stream, long length, String fileName, String mimeType) {
if (fileParams == null) {
fileParams = new HashMap<String, ContentBody>();
}
fileParams.put(key, new InputStreamBody(stream, length, fileName, mimeType));
}
public void setBodyEntity(HttpEntity bodyEntity) {
this.bodyEntity = bodyEntity;
if (bodyParams != null) {
bodyParams.clear();
bodyParams = null;
}
if (fileParams != null) {
fileParams.clear();
fileParams = null;
}
}
/**
* Returns an HttpEntity containing all request parameters
*/
public HttpEntity getEntity() {
if (bodyEntity != null) {
return bodyEntity;
}
HttpEntity result = null;
if (fileParams != null && !fileParams.isEmpty()) {
MultipartEntity multipartEntity = new MultipartEntity(HttpMultipartMode.STRICT, null, Charset.forName(charset));
if (bodyParams != null && !bodyParams.isEmpty()) {
for (NameValuePair param : bodyParams) {
try {
multipartEntity.addPart(param.getName(), new StringBody(param.getValue()));
} catch (UnsupportedEncodingException e) {
LogUtils.e(e.getMessage(), e);
}
}
}
for (ConcurrentHashMap.Entry<String, ContentBody> entry : fileParams.entrySet()) {
multipartEntity.addPart(entry.getKey(), entry.getValue());
}
result = multipartEntity;
} else if (bodyParams != null && !bodyParams.isEmpty()) {
result = new BodyParamsEntity(bodyParams, charset);
}
return result;
}
public List<NameValuePair> getQueryStringParams() {
return queryStringParams;
}
public List<HeaderItem> getHeaders() {
return headers;
}
public class HeaderItem {
public final boolean overwrite;
public final Header header;
public HeaderItem(Header header) {
this.overwrite = false;
this.header = header;
}
public HeaderItem(Header header, boolean overwrite) {
this.overwrite = overwrite;
this.header = header;
}
public HeaderItem(String name, String value) {
this.overwrite = false;
this.header = new BasicHeader(name, value);
}
public HeaderItem(String name, String value, boolean overwrite) {
this.overwrite = overwrite;
this.header = new BasicHeader(name, value);
}
}