Voici ma mise en œuvre et cela fonctionne pour la poste et obtenir. Vous pouvez comparer la configuration avec la vôtre.
/**
* Allows you to easily make URL requests
*
*
* @author Jack Matthews
*
*/
class HttpUrlRequest extends Thread {
private static final String TAG = "HttpUrlRequest";
private static final HttpClient httpClient;
static {
HttpParams params = new BasicHttpParams();
HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);
HttpProtocolParams.setContentCharset(params, HTTP.UTF_8);
HttpProtocolParams.setUseExpectContinue(params, false);
HttpConnectionParams.setConnectionTimeout(params, 10000);
HttpConnectionParams.setSoTimeout(params, 10000);
ConnManagerParams.setMaxTotalConnections(params, 100);
ConnManagerParams.setTimeout(params, 30000);
SchemeRegistry registry = new SchemeRegistry();
registry.register(new Scheme("http",PlainSocketFactory.getSocketFactory(), 80));
registry.register(new Scheme("https",PlainSocketFactory.getSocketFactory(), 80));
ThreadSafeClientConnManager manager = new ThreadSafeClientConnManager(params, registry);
httpClient = new DefaultHttpClient(manager, params);
//httpClient.getParams().setParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, 30000);
}
//user supplied variables
private String host = null;
private int port = 80;
private String path = null;
private List<NameValuePair> query = null;
private List<NameValuePair> post = null;
private Handler handler = null;
private HttpResponseWrapper callbackWrapper = null;
private String scheme = "http";
/**
* Used to setup a request to a url
*
* @param host
* @param port
* @param path
* @param query
* @param post
* @param handler
* @param callbackWrapper
*/
private HttpUrlRequest(String scheme, String host, int port, String path, List<NameValuePair> query, List<NameValuePair> post, Handler handler, HttpResponseWrapper callbackWrapper) {
this.scheme = scheme;
this.host = host;
this.port = port;
this.path = path;
this.query = query;
this.post = post;
this.handler = handler;
this.callbackWrapper = callbackWrapper;
}
/**
* Use this class if your class is implementing HttpResponseListener.
* Creates the request inside it's own Thread automatically.
* <b>run() is called automatically</b>
*
* @param host
* @param port
* @param path
* @param queryString
* @param postData
* @param requestCode
* @param callback
*
* @see HttpResponseListener
*/
public static void sendRequest(String scheme, String host, int port, String path, List<NameValuePair> queryString, List<NameValuePair> postData, int requestCode, HttpResponseListener callback) {
(new HttpUrlRequest(scheme, host, port, path, queryString, postData, new Handler(),new HttpResponseWrapper(callback,requestCode))).start();
}
/**
* Use this method if you want to control the Threading yourself.
*
* @param host
* @param port
* @param path
* @param queryString
* @param postData
* @return
*/
public static HttpResponse sendRequestForImmediateResponse(String scheme,String host, int port, String path, List<NameValuePair> queryString, List<NameValuePair> postData) {
HttpUrlRequest req = new HttpUrlRequest(scheme, host, port, path, queryString, postData, null, null);
return req.runInCurrentThread();
}
/**
* Runs the request in the current Thread, use this if you
* want to mananage Threading yourself through a thread pool etc.
*
* @return HttpResponse
*/
private HttpResponse runInCurrentThread() {
if(post==null) {
return simpleGetRequest();
} else {
return simplePostRequest();
}
}
@Override
public void run() {
//Determine the appropriate method to use
if(post==null) {
callbackWrapper.setResponse(simpleGetRequest());
handler.post(callbackWrapper);
} else {
callbackWrapper.setResponse(simplePostRequest());
handler.post(callbackWrapper);
}
}
/**
* Send a GET request
*
* @return HttpResponse or null if an exception occurred
*
*/
private HttpResponse simpleGetRequest() {
try {
//Add lang to query string
query.add(new BasicNameValuePair("lang", getLanguageInJoomlaFormat()));
URI uri = URIUtils.createURI(scheme, host, port, path, URLEncodedUtils.format(query, HTTP.UTF_8), null);
if(Logging.DEBUG) Log.d(TAG, uri.toString());
//GET method
HttpGet method = new HttpGet(uri);
HttpResponse response = httpClient.execute(method);
//HttpEntity entity = response.getEntity();
if(response==null)
return NullHttpResponse.INSTANCE;
else
return response;
} catch (ClientProtocolException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (URISyntaxException e) {
e.printStackTrace();
}
return NullHttpResponse.INSTANCE;
}
/**
* Send a POST request
*
*
* @return HttpResponse or null if an exception occurred
*
*/
private HttpResponse simplePostRequest() {
try {
//Add lang to query string
query.add(new BasicNameValuePair("lang", getLanguageInJoomlaFormat()));
URI uri = URIUtils.createURI(scheme, host, port, path, URLEncodedUtils.format(query, HTTP.UTF_8), null);
if(Logging.DEBUG) Log.d(TAG, uri.toString());
//POST method
HttpPost postMethod=new HttpPost(uri);
postMethod.setEntity(new UrlEncodedFormEntity(post, HTTP.UTF_8));
HttpResponse response = httpClient.execute(postMethod);
//HttpEntity entity = response.getEntity();
if(response==null)
return NullHttpResponse.INSTANCE;
else
return response;
} catch (UnsupportedEncodingException e) {
if(Logging.ERROR) Log.e(TAG, "UnsupportedEncodingException", e);
} catch (ClientProtocolException e) {
if(Logging.ERROR) Log.e(TAG, "UnsupportedEncodingException", e);
} catch (IOException e) {
if(Logging.ERROR) Log.e(TAG, "UnsupportedEncodingException", e);
} catch (URISyntaxException e) {
if(Logging.ERROR) Log.e(TAG, "UnsupportedEncodingException", e);
}
return NullHttpResponse.INSTANCE;
}
/**
* Converts the language code to correct Joomla format
*
* @return language in the (en-GB)
*/
public static String getLanguageInJoomlaFormat() {
String joomlaName;
String[] tokens = Locale.getDefault().toString().split("_");
if (tokens.length >= 2 && tokens[1].length() == 2) {
joomlaName = tokens[0]+"-"+tokens[1];
} else {
joomlaName = tokens[0]+"-"+tokens[0].toUpperCase();
}
return joomlaName;
}
/**
* Creates a null http response
*
* @author Jack Matthews
*
*/
private enum NullHttpResponse implements HttpResponse {
INSTANCE;
@Override
public HttpEntity getEntity() {
return null;
}
@Override
public Locale getLocale() {
return null;
}
@Override
public StatusLine getStatusLine() {
return null;
}
@Override
public void setEntity(HttpEntity entity) {
}
@Override
public void setLocale(Locale loc) {
}
@Override
public void setReasonPhrase(String reason) throws IllegalStateException {
}
@Override
public void setStatusCode(int code) throws IllegalStateException {
}
@Override
public void setStatusLine(StatusLine statusline) {
}
@Override
public void setStatusLine(ProtocolVersion ver, int code) {
}
@Override
public void setStatusLine(ProtocolVersion ver, int code, String reason) {
}
@Override
public void addHeader(Header header) {
}
@Override
public void addHeader(String name, String value) {
}
@Override
public boolean containsHeader(String name) {
return false;
}
@Override
public Header[] getAllHeaders() {
return null;
}
@Override
public Header getFirstHeader(String name) {
return null;
}
@Override
public Header[] getHeaders(String name) {
return null;
}
@Override
public Header getLastHeader(String name) {
return null;
}
@Override
public HttpParams getParams() {
return null;
}
@Override
public ProtocolVersion getProtocolVersion() {
return null;
}
@Override
public HeaderIterator headerIterator() {
return null;
}
@Override
public HeaderIterator headerIterator(String name) {
return null;
}
@Override
public void removeHeader(Header header) {
}
@Override
public void removeHeaders(String name) {
}
@Override
public void setHeader(Header header) {
}
@Override
public void setHeader(String name, String value) {
}
@Override
public void setHeaders(Header[] headers) {
}
@Override
public void setParams(HttpParams params) {
}
}
}