public String sendLoginData(LoginData data) {
String responseMessage = null;
try {
System.out.println("SENDING >>>>>>>>>");
HttpClient httpclient = new DefaultHttpClient();
HttpPost httppost = new HttpPost("http://system.smartsales.bg/user/android_login/");
// Add your data
List<NameValuePair> nameValuePairs = new ArrayList<NameValuePair>(2);
nameValuePairs.add(new BasicNameValuePair("email", data.getEmail()));
nameValuePairs.add(new BasicNameValuePair("password", data.getPassword()));
httppost.setEntity(new UrlEncodedFormEntity(nameValuePairs));
// Execute HTTP Post Request
HttpResponse response = httpclient.execute(httppost);
responseMessage = EntityUtils.toString(response.getEntity());
} catch (Exception e) {
e.printStackTrace();
}
return responseMessage;
}
public void run() {
HttpPost httpPost =
new HttpPost(initParams.getRemoteContactPointEncoded(lastReceivedTimestamp));
//
httpPost.getParams().setParameter(CoreProtocolPNames.USE_EXPECT_CONTINUE, Boolean.FALSE);
//
HttpResponse response = null; // This is acting as keep alive.
//
while (isActive()) {
try {
Thread.sleep(KEEP_ALIVE_PERIOD);
httpPost.setEntity(new UrlEncodedFormEntity(postParameters, HTTP.UTF_8));
response = null;
response = httpclient.execute(httpPost);
int status = response.getStatusLine().getStatusCode();
if (status != RestStreamHanlder.SUCCESS_200) {
logger.error(
"Cant register to the remote client, retrying in:"
+ (KEEP_ALIVE_PERIOD / 1000)
+ " seconds.");
structure = registerAndGetStructure();
}
} catch (Exception e) {
logger.warn(e.getMessage(), e);
} finally {
if (response != null) {
try {
response.getEntity().getContent().close();
} catch (Exception e) {
logger.warn(e.getMessage(), e);
}
}
}
}
}
public static InputStream post(Context context, String url, ArrayList<NameValuePair> params) {
mLogger = Logger.getLogger();
InputStream in = null;
try {
UrlEncodedFormEntity entity = new UrlEncodedFormEntity(params, CHARSET);
HttpPost request = new HttpPost(url);
request.setEntity(entity);
HttpClient client = getInstance(context);
HttpResponse response = client.execute(request);
if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
HttpEntity resEntity = response.getEntity();
in = (resEntity == null) ? null : resEntity.getContent();
}
} catch (IOException e) {
e.printStackTrace();
mLogger.e("error:" + e.getMessage());
} catch (Exception e) {
e.printStackTrace();
mLogger.e("error:" + e.getMessage());
}
return in;
}
@Override
protected String doInBackground(String... params) {
// TODO Auto-generated method stub
try {
StringEntity se;
// Log.e("http string",URL+"//"+send.toString());
HttpParams httpParameters = new BasicHttpParams(); // set connection parameters
HttpConnectionParams.setConnectionTimeout(httpParameters, 60000);
HttpConnectionParams.setSoTimeout(httpParameters, 60000);
HttpClient httpclient = new DefaultHttpClient(httpParameters);
HttpResponse response = null;
HttpPost httppost = new HttpPost(params[0]);
httppost.setHeader("Content-type", "application/json");
se = new StringEntity(params[1]);
se.setContentType(new BasicHeader(HTTP.CONTENT_TYPE, "application/json"));
httppost.setEntity(se);
response = httpclient.execute(httppost);
HttpEntity entity = response.getEntity();
InputStream is = entity.getContent();
streamtostring(is);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
@Test
public static void depositeDetailTest() throws Exception {
CloseableHttpClient httpclient = HttpClients.createDefault();
try {
HttpPost post = new HttpPost("http://192.168.2.111:8578/service?channel=QueryNoticePage");
List<NameValuePair> list = new ArrayList<NameValuePair>();
list.add(new BasicNameValuePair("platformId", "82044"));
list.add(new BasicNameValuePair("appKey", "1"));
post.setEntity(new UrlEncodedFormEntity(list));
CloseableHttpResponse response = httpclient.execute(post);
try {
System.out.println(response.getStatusLine());
HttpEntity entity2 = response.getEntity();
String entity = EntityUtils.toString(entity2);
if (entity.contains("code\":\"0")) {
System.out.println("Success!");
System.out.println("response content:" + entity);
} else {
System.out.println("Failure!");
System.out.println("response content:" + entity);
AssertJUnit.fail(entity);
}
} finally {
response.close();
}
} finally {
httpclient.close();
}
}
@Override
protected String doInBackground(JSONObject... params) {
HttpClient httpClient = new DefaultHttpClient();
JSONObject json = params[0];
try {
HttpPost request = new HttpPost(restfulURL);
System.out.println("JSON DATA2 : " + json.toString());
StringEntity entity = new StringEntity(json.toString(), "UTF-8");
entity.setContentType("application/json");
request.setEntity(entity);
HttpResponse response = httpClient.execute(request);
System.out.println("Status Code : " + response.getStatusLine());
BufferedReader rd =
new BufferedReader(new InputStreamReader(response.getEntity().getContent()));
StringBuffer sb = new StringBuffer("");
String line = "";
String NL = System.getProperty("line.separator");
while ((line = rd.readLine()) != null) {
sb.append(line + NL);
}
rd.close();
return sb.toString();
} catch (Exception e) {
System.out.println(e.getMessage());
}
return "";
}
@RequestMapping(value = "/kkn1234/create", method = RequestMethod.POST)
public String formSubmit(@ModelAttribute User user, Model model)
throws MalformedURLException, IOException {
model.addAttribute("user", user);
HttpPost post =
new HttpPost(
"http://ec2-52-4-138-196.compute-1.amazonaws.com/magento/index.php/customer/account/createpost/");
BasicCookieStore cookieStore = new BasicCookieStore();
CloseableHttpClient httpclient =
HttpClients.custom().setDefaultCookieStore(cookieStore).build();
List<NameValuePair> nameValuePairs = new ArrayList<NameValuePair>();
nameValuePairs.add(new BasicNameValuePair("firstname", user.getFirstName()));
nameValuePairs.add(new BasicNameValuePair("lastname", user.getLastName()));
nameValuePairs.add(new BasicNameValuePair("email", user.getEmail()));
nameValuePairs.add(new BasicNameValuePair("password", user.getPassword()));
nameValuePairs.add(new BasicNameValuePair("confirmation", user.getConfirmation()));
post.setEntity(new UrlEncodedFormEntity(nameValuePairs));
HttpResponse response = httpclient.execute(post);
response = httpclient.execute(post);
System.out.println("Status code is " + response.getStatusLine().getStatusCode());
System.out.println(response.toString());
System.out.println("+++++++++++++++++++++++++++++++++++++++++++++++++++++");
System.out.println(response.getFirstHeader("Location"));
HttpEntity entity = response.getEntity();
EntityUtils.consume(entity);
EntityUtils.consume(response.getEntity());
/*File newTextFile = new File("C:\\Users\\Kris\\Desktop\\temp.html");
FileWriter fileWriter = new FileWriter(newTextFile);
fileWriter.write(response.toString());
fileWriter.close();*/
return "result";
}
public static String doPost(String url, Map<String, String> params, String jsonStr) {
logger.info(jsonStr);
client = getHttpClientInstance();
URI uri = generateURLParams(url, params);
HttpPost post = new HttpPost(uri);
post.setConfig(requestConfig);
String responseStr = null;
CloseableHttpResponse httpResponse = null;
try {
HttpEntity entity = new StringEntity(jsonStr, DEFAULT_CHARSET);
post.setEntity(entity);
post.setHeader("Content-Type", "application/json");
httpResponse = client.execute(post);
responseStr = generateHttpResponse(httpResponse);
} catch (IOException e) {
e.printStackTrace();
} finally {
if (null != httpResponse) {
try {
httpResponse.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return responseStr;
}
// create datastream
public Datastream createDatastream(Integer feedid, Datastream datastream) throws CosmException {
try {
HttpPost request =
new HttpPost(
API_BASE_URL_V2
+ API_RESOURCE_FEEDS
+ "/"
+ feedid
+ "/datastreams"
+ JSON_FILE_EXTENSION);
JSONObject jo = new JSONObject();
jo.put("version", Cosm.VERSION);
JSONArray ja = new JSONArray();
ja.put(datastream.toJSONObject());
jo.put("datastreams", ja);
request.setEntity(new StringEntity(jo.toString()));
HttpResponse response = this.client.execute(request);
StatusLine statusLine = response.getStatusLine();
if (statusLine.getStatusCode() == 201) {
String a[] = response.getHeaders(HEADER_PARAM_LOCATION)[0].getValue().split("/");
String datastreamid = a[a.length - 1];
this.client.getBody(response);
return this.getDatastream(feedid, datastreamid);
}
throw new HttpException(response.getStatusLine().toString());
} catch (Exception e) {
e.printStackTrace();
throw new CosmException("Caught exception in create Datastream" + e.getMessage());
}
}
private String spejdPost(JsonObject jo) {
@SuppressWarnings({"resource"})
DefaultHttpClient httpclient = new DefaultHttpClient();
HttpResponse resp;
HttpPost httpPost = new HttpPost(SPEJD_SERVICE_POST);
httpPost.addHeader("Content-Type", "application/json");
StringEntity reqEntity = null;
try {
reqEntity = new StringEntity(jo.toString());
} catch (UnsupportedEncodingException e) {
System.out.println(e.toString());
}
assert reqEntity != null;
httpPost.setEntity(reqEntity);
try {
resp = httpclient.execute(httpPost);
return EntityUtils.toString(resp.getEntity());
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
public JSONObject makeHttpRequest(String url, List<NameValuePair> params) {
// Making HTTP request
try {
DefaultHttpClient httpClient = new DefaultHttpClient();
HttpPost httpPost = new HttpPost(url);
// Depends on your web service
httpPost.setHeader("Content-Type", "application/x-www-form-urlencoded");
httpPost.setEntity(new UrlEncodedFormEntity(params));
HttpResponse httpResponse = httpClient.execute(httpPost);
HttpEntity httpEntity = httpResponse.getEntity();
InputStreamReader isr = new InputStreamReader(httpEntity.getContent());
BufferedReader reader = new BufferedReader(isr);
StringBuilder sb = new StringBuilder();
String line = null;
while ((line = reader.readLine()) != null) {
sb.append(line + "\n");
}
json = sb.toString();
} catch (Exception e) {
Log.e("Buffer Error", "::::Error converting result " + e.toString());
}
// try parse the string to a JSON object
try {
jObj = new JSONObject(json);
} catch (JSONException e) {
Log.e("JSON Parser", "::::Error parsing data " + e.toString());
}
return jObj;
}
@Override
protected Boolean doInBackground(File... params) {
String server = BuildConfig.API_BASE_URL;
ICredentials credentials = new UserCredentials(mContext);
String url = server + "/api/nodes/" + wmID + "/photos?api_key=" + credentials.getApiKey();
Log.d(TAG, url);
File image = params[0];
HttpClient httpclient = new DefaultHttpClient();
HttpPost httppost = new HttpPost(url);
try {
MultipartEntity entity = new MultipartEntity();
entity.addPart("photo", new FileBody(image));
httppost.setEntity(entity);
HttpResponse response = httpclient.execute(httppost);
String result = EntityUtils.toString(response.getEntity());
Log.d(TAG, result + "");
return true;
} catch (Exception e) {
e.printStackTrace();
Log.d(TAG, e.getLocalizedMessage());
return false;
}
}
private Map<String, String> loadAllToks(final String code, int port, final HttpClient httpClient)
throws IOException {
final HttpPost post = new HttpPost("https://accounts.google.com/o/oauth2/token");
try {
final List<? extends NameValuePair> nvps =
Arrays.asList(
new BasicNameValuePair("code", code),
new BasicNameValuePair("client_id", model.getSettings().getClientID()),
new BasicNameValuePair("client_secret", model.getSettings().getClientSecret()),
new BasicNameValuePair("redirect_uri", OauthUtils.getRedirectUrl(port)),
new BasicNameValuePair("grant_type", "authorization_code"));
final HttpEntity entity = new UrlEncodedFormEntity(nvps, LanternConstants.UTF8);
post.setEntity(entity);
log.debug("About to execute post!");
final HttpResponse response = httpClient.execute(post);
log.debug("Got response status: {}", response.getStatusLine());
final HttpEntity responseEntity = response.getEntity();
final String body = IOUtils.toString(responseEntity.getContent());
EntityUtils.consume(responseEntity);
final Map<String, String> oauthToks = JsonUtils.OBJECT_MAPPER.readValue(body, Map.class);
log.debug("Got oath data: {}", oauthToks);
return oauthToks;
} finally {
post.reset();
}
}
public static String invokeServer(String serverURL, String params) throws Exception {
try {
JSONObject jsonParams = new JSONObject(params);
String belongProject = XcmApplication.getInstance().gettMetaData();
jsonParams.put("belong_project", belongProject);
LogUtil.e("gomtel", "belong_project= " + belongProject);
params = jsonParams.toString();
StringEntity se = new StringEntity(params);
HttpParams paramsw = createHttpParams();
se.setContentEncoding(new BasicHeader(HTTP.CONTENT_TYPE, "application/json"));
HttpPost post = new HttpPost(serverURL);
post.setEntity(se);
HttpResponse response = new DefaultHttpClient(paramsw).execute(post);
int sCode = response.getStatusLine().getStatusCode();
if (sCode == HttpStatus.SC_OK) {
return EntityUtils.toString(response.getEntity());
} else {
JSONObject json = new JSONObject();
json.put("resultCode", -6);
return json.toString(); // 链接不上后台
}
} catch (Exception e) {
JSONObject json = new JSONObject();
json.put("resultCode", -6);
return json.toString(); // 链接不上后台
}
}
// create datapoint
public void createDatapoint(Integer feedid, String datastreamid, Datapoint datapoint)
throws CosmException {
try {
HttpPost request =
new HttpPost(
API_BASE_URL_V2
+ API_RESOURCE_FEEDS
+ "/"
+ feedid
+ "/datastreams/"
+ datastreamid
+ "/datapoints"
+ JSON_FILE_EXTENSION);
JSONObject jo = new JSONObject();
JSONArray ja = new JSONArray();
ja.put(datapoint.toJSONObject());
jo.put("datapoints", ja);
request.setEntity(new StringEntity(jo.toString()));
HttpResponse response = this.client.execute(request);
StatusLine statusLine = response.getStatusLine();
this.client.getBody(response);
if (statusLine.getStatusCode() != 200) {
throw new CosmException(response.getStatusLine().toString());
}
} catch (Exception e) {
e.printStackTrace();
throw new CosmException("Caught exception in create datapoint" + e.getMessage());
}
}
public String postUser(String username) {
String uri = "http://10.0.2.2:8090/user";
List<NameValuePair> passParams = new ArrayList<NameValuePair>(1);
passParams.add(new BasicNameValuePair("username", username));
HttpClient httpClient = new DefaultHttpClient();
HttpPost httpPost = new HttpPost(uri);
// Log.d("loltale:params", Integer.toString(params.length));
try {
httpPost.setEntity(new UrlEncodedFormEntity(passParams));
HttpResponse response = httpClient.execute(httpPost);
HttpEntity entity = response.getEntity();
if (entity != null) {
return EntityUtils.toString(entity);
}
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
} catch (ClientProtocolException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
// create datapoints
public void createDatapoints(Integer feedid, String datastreamid, Datapoint[] datapoints)
throws CosmException {
try {
HttpPost request =
new HttpPost(
API_BASE_URL_V2
+ API_RESOURCE_FEEDS
+ "/"
+ feedid
+ "/datastreams/"
+ datastreamid
+ "/datapoints"
+ JSON_FILE_EXTENSION);
JSONObject jo = new JSONObject();
JSONArray ja = new JSONArray();
for (int i = 0; (i < datapoints.length); i++) {
ja.put(datapoints[i].toJSONObject());
}
jo.put("datapoints", ja);
request.setEntity(new StringEntity(jo.toString()));
HttpResponse response = this.client.execute(request);
StatusLine statusLine = response.getStatusLine();
String body = this.client.getBody(response);
if (statusLine.getStatusCode() != 200) {
JSONObject ej = new JSONObject(body);
throw new CosmException(ej.getString("errors"));
}
} catch (Exception e) {
throw new CosmException("Caught exception in create datapoint" + e.getMessage());
}
}
public static String uploadMaterial(
String url, Map<String, String> params, String formDataName, File file) {
client = getHttpClientInstance();
URI uri = generateURLParams(url, params);
HttpPost post = new HttpPost(uri);
post.setConfig(requestConfig);
ContentBody contentBody = new FileBody(file);
HttpEntity reqestEntity =
MultipartEntityBuilder.create().addPart(formDataName, contentBody).build();
post.setEntity(reqestEntity);
String responseStr = null;
CloseableHttpResponse httpResponse = null;
try {
httpResponse = client.execute(post);
responseStr = generateHttpResponse(httpResponse);
} catch (IOException e) {
} finally {
if (null != httpResponse) {
try {
httpResponse.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return responseStr;
}
// This method is executed in the background thread on our Survey object
private String uploadSurveyData(String myXML) {
// Set up communication with the server
DefaultHttpClient client = new DefaultHttpClient();
String result = null;
//
HttpPost httpPost;
httpPost =
new HttpPost(
"http://YOUR DOMAIN HERE/survey-webApp/index.php/webUser_Controllers/android_controller/save_survey_xml");
try {
// Encode the xml, add header and set it to POST request
StringEntity entity = new StringEntity(myXML, HTTP.UTF_8);
// entity.setContentType("text/xml");
httpPost.setEntity(entity);
// Execute POST request and get response
HttpResponse response = client.execute(httpPost);
HttpEntity responseEntity = response.getEntity();
// System.out.print(EntityUtils.toString(responseEntity));
// Set up XML parsing objects
SAXParserFactory spf = SAXParserFactory.newInstance();
SAXParser sp = spf.newSAXParser();
XMLReader xr = sp.getXMLReader();
// Set up an instance of our class to parse the status response
HttpResponseHandler myResponseHandler = new HttpResponseHandler();
xr.setContentHandler(myResponseHandler);
xr.parse(retrieveInputStream(responseEntity));
// check myResponseHandler for response
result = myResponseHandler.getStatus();
} catch (Exception e) {
result = "Exception - " + e.getMessage();
}
return result;
}
private HttpUriRequest createRequest(ApiRequest rawRequest) throws HttpException {
HttpUriRequest uriRequest = null;
String url = rawRequest.getCompleteUrl();
switch (rawRequest.getMethod()) {
case GET:
uriRequest = new HttpGet(url);
break;
case POST:
HttpPost post = new HttpPost(url);
HttpEntity entity = null;
try {
if (rawRequest.hasFile()) {
entity =
createMultipartEntity(
rawRequest.getFileName(), rawRequest.getFile(), rawRequest.getPostParams());
} else {
entity = new UrlEncodedFormEntity(rawRequest.getPostParams(), HTTP.UTF_8);
}
} catch (IOException e) {
throw new HttpException(e.getMessage(), e);
}
post.setEntity(entity);
uriRequest = post;
break;
}
setHeaders(uriRequest, rawRequest.getHeaders());
return uriRequest;
}
public final void run() {
proccess();
CloseableHttpClient httpclient = HttpClients.createDefault();
HttpPost httpPost =
new HttpPost(
"https://api.telegram.org/bot115447632:AAGiH7bX_7dpywsXWONvsJPESQe-N7EmcQI/sendMessage");
httpPost.addHeader("Content-type", "application/x-www-form-urlencoded");
httpPost.addHeader("charset", "UTF-8");
List<NameValuePair> urlParameters = new ArrayList<NameValuePair>();
urlParameters.add(new BasicNameValuePair("chat_id", String.valueOf(update.message.chat.id)));
urlParameters.add(new BasicNameValuePair("text", mensagem));
if (teclado != null) urlParameters.add(new BasicNameValuePair("reply_markup", teclado));
if (mensagemRetornoID != null)
urlParameters.add(
new BasicNameValuePair("reply_to_message_id", mensagemRetornoID.toString()));
try {
httpPost.setEntity(new UrlEncodedFormEntity(urlParameters, "UTF-8"));
httpclient.execute(httpPost);
} catch (IOException e) {
e.printStackTrace();
}
}
@Override
public void insertOrUpdatePreferences(EasitApplicationPreferences preferences, EasitAccount user)
throws Exception {
// Convert the prefs to
String strPrefs = localPrefsToServerPrefs(preferences);
// Prepare request and send it
DefaultHttpClient client = new DefaultHttpClient();
StringEntity input = new StringEntity(strPrefs);
input.setContentEncoding("UTF8");
input.setContentType("application/json");
HttpPost postRequest =
new HttpPost(
environment.getProperty("flowManager.url") + "/oldpreferences/" + user.getUserToken());
postRequest.setEntity(input);
HttpResponse response = client.execute(postRequest);
// NOT Correct answer
if (response.getStatusLine().getStatusCode() != 200) {
logger.info("ERROR:");
logger.info(
"URL target"
+ environment.getProperty("flowManager.url")
+ "/oldpreferences/"
+ user.getUserToken());
throw new Exception("Failed : HTTP error code : " + response.getStatusLine().getStatusCode());
}
// Clear connection
client.getConnectionManager().shutdown();
}
/**
* @param url
* @param formData 提交的数
* @throws IOException
*/
public static void post(String url, Map<String, Object> formData) throws Exception {
HttpClient client = HttpClients.createDefault();
HttpPost post = new HttpPost(url);
List<NameValuePair> formparams = new ArrayList<NameValuePair>();
if (formData != null) {
Iterator<Map.Entry<String, Object>> iterator = formData.entrySet().iterator();
while (iterator.hasNext()) {
Map.Entry<String, Object> next = iterator.next();
String key = next.getKey();
Object value = next.getValue();
formparams.add(new BasicNameValuePair(key, value.toString()));
}
}
HttpEntity reqEntity = new UrlEncodedFormEntity(formparams, "utf-8");
RequestConfig requestConfig =
RequestConfig.custom()
.setSocketTimeout(50000)
.setConnectTimeout(50000)
.setConnectionRequestTimeout(50000)
.build();
post.setEntity(reqEntity);
post.setConfig(requestConfig);
HttpResponse response = client.execute(post);
if (response.getStatusLine().getStatusCode() != 200) {
throw new Exception("请求失败");
}
}
/**
* POSTs the variables and returns the body
*
* @param url - fully qualified and encoded URL to post to
* @param params
* @return
*/
public String doPost(String url, Map<String, String> params)
throws com.ettrema.httpclient.HttpException, NotAuthorizedException, ConflictException,
BadRequestException, NotFoundException {
notifyStartRequest();
HttpPost m = new HttpPost(url);
List<NameValuePair> formparams = new ArrayList<NameValuePair>();
for (Entry<String, String> entry : params.entrySet()) {
formparams.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
}
UrlEncodedFormEntity entity;
try {
entity = new UrlEncodedFormEntity(formparams);
} catch (UnsupportedEncodingException ex) {
throw new RuntimeException(ex);
}
m.setEntity(entity);
try {
ByteArrayOutputStream bout = new ByteArrayOutputStream();
int res = Utils.executeHttpWithStatus(client, m, bout);
Utils.processResultCode(res, url);
return bout.toString();
} catch (HttpException ex) {
throw new RuntimeException(ex);
} catch (IOException ex) {
throw new RuntimeException(ex);
} finally {
notifyFinishRequest();
}
}
private void initQuery() throws IOException {
Hashtable<String, String> map = new Hashtable<String, String>();
map.put("uid", "TEMP_USER");
map.put("pwd", "TEMP_PASSWORD");
map.put(QUERY_PARAM, Base64.encodeToString(TEST_QUERY.getBytes(), 0));
HttpParams params = new BasicHttpParams();
HttpConnectionParams.setStaleCheckingEnabled(params, false);
HttpConnectionParams.setConnectionTimeout(params, ConnectionManager.DEFAULT_TIMEOUT);
HttpConnectionParams.setSoTimeout(params, ConnectionManager.DEFAULT_TIMEOUT);
DefaultHttpClient httpClient = new DefaultHttpClient(params);
// create post method
HttpPost postMethod = new HttpPost(QUERY_URI);
ByteArrayOutputStream byteArrayOS = new ByteArrayOutputStream();
ObjectOutputStream objOS = new ObjectOutputStream(byteArrayOS);
objOS.writeObject(map);
ByteArrayEntity req_entity = new ByteArrayEntity(byteArrayOS.toByteArray());
req_entity.setContentType(MIMETypeConstantsIF.BINARY_TYPE);
// associating entity with method
postMethod.setEntity(req_entity);
// Executing post method
executeHttpClient(httpClient, postMethod);
}
@Override
public Object execute(Request request) {
HttpRequestBase httpRequest = null;
if (request.getMethod() == Request.POST) {
HttpPost post = new HttpPost(request.getUrl());
Object obj = request.getEntity();
if (obj != null) {
HttpEntity entity = null;
if (request.isMultiPart()) {
entity = new MultipartRequestEntity((MimeMultipart) obj);
} else {
try {
entity = new StringEntity(obj.toString(), Charsets.UTF_8);
} catch (UnsupportedCharsetException e) {
throw new Error("Cannot encode into UTF-8", e);
}
}
post.setEntity(entity);
}
httpRequest = post;
} else {
httpRequest = new HttpGet(request.getUrl());
}
try {
return execute(request, httpRequest);
} catch (RemoteException e) {
throw e;
} catch (Exception e) {
throw new RuntimeException("Cannot execute " + request, e);
}
}
@Override
protected String doInBackground(String... params) {
Log.d("check", "doing in back");
HttpClient httpClient = new DefaultHttpClient();
HttpPost httpPost = new HttpPost("http://84.200.84.218/flint/checkuname.php");
List<NameValuePair> nameValuePairList = new ArrayList<NameValuePair>(1);
nameValuePairList.add(new BasicNameValuePair("uname", suname));
HttpResponse httpResponse = null;
try {
httpPost.setEntity(new UrlEncodedFormEntity(nameValuePairList));
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
try {
httpResponse = httpClient.execute(httpPost);
Log.d("response:", httpResponse.toString());
// Toast.makeText(getApplicationContext(),httpResponse.toString(),Toast.LENGTH_LONG).show();
} catch (IOException e) {
e.printStackTrace();
}
String data = null;
HttpEntity ent = httpResponse.getEntity();
try {
data = EntityUtils.toString(ent);
} catch (IOException e) {
e.printStackTrace();
}
Log.d("check", "doing in back done");
return data;
}
public static String sendToRockBlockHttp(
String destImei, String username, String password, byte[] data)
throws HttpException, IOException {
CloseableHttpClient client = HttpClientBuilder.create().build();
HttpPost post = new HttpPost("https://secure.rock7mobile.com/rockblock/MT");
List<NameValuePair> urlParameters = new ArrayList<NameValuePair>();
urlParameters.add(new BasicNameValuePair("imei", destImei));
urlParameters.add(new BasicNameValuePair("username", username));
urlParameters.add(new BasicNameValuePair("password", password));
urlParameters.add(new BasicNameValuePair("data", ByteUtil.encodeToHex(data)));
post.setEntity(new UrlEncodedFormEntity(urlParameters));
post.setHeader("Content-Type", "application/x-www-form-urlencoded");
HttpResponse response = client.execute(post);
BufferedReader rd =
new BufferedReader(new InputStreamReader(response.getEntity().getContent()));
StringBuffer result = new StringBuffer();
String line = "";
while ((line = rd.readLine()) != null) {
result.append(line);
}
try {
client.close();
} catch (Exception e) {
e.printStackTrace();
}
return result.toString();
}
@Test
public void testMultipart() throws IOException, JSONException {
HttpClient httpclient = new DefaultHttpClient();
HttpPost httppost = new HttpPost("http://localhost:" + PORT + "/");
File image = new File("resources/test/base.png");
FileBody imagePart = new FileBody(image);
StringBody messagePart = new StringBody("some message");
MultipartEntity req = new MultipartEntity();
req.addPart("image", imagePart);
req.addPart("message", messagePart);
httppost.setEntity(req);
ImageEchoServer server = new ImageEchoServer(PORT);
HttpResponse response = httpclient.execute(httppost);
server.stop();
HttpEntity resp = response.getEntity();
assertThat(resp.getContentType().getValue(), is("application/json"));
// sweet one-liner to convert an inputstream to a string from stackoverflow:
// http://stackoverflow.com/questions/309424/in-java-how-do-i-read-convert-an-inputstream-to-a-string
String out = new Scanner(resp.getContent()).useDelimiter("\\A").next();
JSONObject json = new JSONObject(out);
String base64 = Base64.encodeFromFile("resources/test/base.png");
assertThat(json.getString("screenshot"), is(base64));
assertThat(json.getBoolean("imageEcho"), is(true));
}
@Test
public void testGetAndCheckKey() throws Exception {
HttpClient httpClient = new DefaultHttpClient();
HttpPost post = new HttpPost("http://*****:*****@gmail.com"));
nvps.add(new BasicNameValuePair("password", "Purbrick7"));
post.setEntity(new UrlEncodedFormEntity(nvps, HTTP.UTF_8));
HttpResponse response = httpClient.execute(post);
assertEquals(200, response.getStatusLine().getStatusCode());
HttpEntity entity = response.getEntity();
String responseContent = IOUtils.toString(entity.getContent());
System.out.println(response.getFirstHeader("Content-Type"));
System.out.println(responseContent);
JSONObject jsonObj = (JSONObject) new JSONParser().parse(responseContent);
HttpPost post2 = new HttpPost("http://*****:*****@gmail.com"));
nvps2.add(new BasicNameValuePair("authKey", (String) jsonObj.get("authKey")));
post2.setEntity(new UrlEncodedFormEntity(nvps2, HTTP.UTF_8));
HttpResponse response2 = httpClient.execute(post2);
assertEquals(200, response2.getStatusLine().getStatusCode());
}