Java Examples for cz.msebera.android.httpclient.Header

public static void report(String message, final ResponseData result) {
    String deviceModel = Build.MODEL;
    String deviceId = Build.ID;
    String deviceSystemVersion = Build.VERSION.RELEASE;
    String deviceName = Build.MODEL;
    String deviceLocalizedModel = Build.MANUFACTURER;
    RequestParams params = new RequestParams();
    params.add("deviceModel", deviceModel);
    params.add("deviceId", deviceId);
    params.add("deviceSystemVersion", deviceSystemVersion);
    params.add("deviceName", deviceName);
    params.add("deviceLocalizedModel", deviceLocalizedModel);
    params.add("message", message);
    ServerLayer.post("report", params, new AsyncHttpResponseHandler() {

        @Override
        public void onSuccess(int statusCode, Header[] headers, byte[] responseBody) {
            result.onSuccess(null);
        }

        @Override
        public void onFailure(int statusCode, Header[] headers, byte[] responseBody, Throwable error) {
            ErrorResponse e = ErrorResponse.create("Nuk mund te dergohet raportimi. Shikoni lidhjen me internet.");
            result.onFailure(e);
        }
    });
}

private void detectIfLocatedInTheUs() {
    if (ConnectionDetector.isConnectingToInternet(this)) {
        HttpRequest.getInstance().get("http://ip-api.com/json/?fields=3", new JsonHttpResponseHandler() {

            @Override
            public void onSuccess(int statusCode, Header[] headers, JSONObject response) {
                if (response != null) {
                    if (response.has("countryCode"))
                        try {
                            isLocatedInTheUs = response.getString("countryCode").toLowerCase().equals("us");
                        } catch (JSONException e) {
                        }
                }
            }
        });
    }
}

@Override
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()) {
        if (request.containsHeader(header)) {
            Header overwritten = request.getFirstHeader(header);
            log.d(LOG_TAG, String.format("Headers were overwritten! (%s | %s) overwrites (%s | %s)", header, clientHeaderMap.get(header), overwritten.getName(), overwritten.getValue()));
            //remove the overwritten header
            request.removeHeader(overwritten);
        }
        request.addHeader(header, clientHeaderMap.get(header));
    }
}

@Override
public void onSuccess(int statusCode, cz.msebera.android.httpclient.Header[] headers, byte[] responseBody) {
    try {
        JSONObject jsonObject = new JSONObject(new String(responseBody));
        List<Region> regions = new ArrayList<>();
        JSONArray regionJSONArray = jsonObject.getJSONArray("regions");
        for (int i = 0; i < regionJSONArray.length(); i++) {
            JSONObject regionJSONObject = regionJSONArray.getJSONObject(i);
            Region region = jsonObjectToRegion(regionJSONObject);
            regions.add(region);
        }
        RegionService.this.deleteAll();
        RegionService.this.saveAll(regions);
        RegionService.this.setRequiresRefresh(true);
    } catch (JSONException e) {
        e.printStackTrace();
    }
}

public static String extractUrls(HttpResponse response) {
    String found = null;
    try {
        Scanner scan;
        Header contentEncoding = response.getFirstHeader("Content-Encoding");
        if (contentEncoding != null && contentEncoding.getValue().equalsIgnoreCase("gzip")) {
            scan = new Scanner(new GZIPInputStream(response.getEntity().getContent()));
        } else {
            scan = new Scanner(response.getEntity().getContent());
        }
        found = scan.findWithinHorizon(url_match_pattern, 0);
        if (null != found) {
            Matcher m = url_match_pattern.matcher(found);
            if (m.matches())
                found = m.group(1);
        }
        scan.close();
        EntityUtils.consume(response.getEntity());
    } catch (Throwable t) {
        Log.e(LOG_TAG, "Error Occurred", t);
    }
    return found;
}

@Override
public void onSuccess(int statusCode, Header[] headers, JSONArray response) {
    super.onSuccess(statusCode, headers, response);
    if (statusCode != 200) {
        callback.onFail();
    } else {
        try {
            JSONObject jsonObject = response.getJSONObject(0);
            AvatarModel model = new AvatarModel();
            model.url = jsonObject.getJSONArray("avatars").getJSONObject(0).getString("url");
            model.firstName = jsonObject.getString("first_name");
            model.lastName = jsonObject.getString("last_name");
            callback.onSuccess(model);
        } catch (JSONException ignore) {
            callback.onFail();
        }
    }
}

private void showImageOnPlotPopup(Plot plot) {
    plot.getTreeThumbnail(new BinaryHttpResponseHandler(Plot.IMAGE_TYPES) {

        @Override
        public void onSuccess(int statusCode, Header[] headers, byte[] imageData) {
            ImageView plotImage = (ImageView) getActivity().findViewById(R.id.plotImage);
            plotImage.setImageBitmap(BitmapFactory.decodeByteArray(imageData, 0, imageData.length));
        }

        @Override
        public void onFailure(int statusCode, Header[] headers, byte[] imageData, Throwable e) {
            // Log the error, but not important enough to bother the user
            Logger.warning("Could not retreive tree image", e);
        }
    });
}

public void load(final FreeFlowArtbookActivity caller, int itemsPerPage, int page) {
    HttpUtilsAsync.get("http://api.dribbble.com/shots/popular?per_page=" + itemsPerPage + "&page=" + page, new AsyncHttpResponseHandler() {

        @Override
        public void onSuccess(int i, Header[] headers, byte[] bytes) {
            DribbbleFeed feed = new Gson().fromJson(new String(bytes), DribbbleFeed.class);
            caller.onDataLoaded(feed);
        }

        @Override
        public void onFailure(int i, Header[] headers, byte[] bytes, Throwable throwable) {
        }
    });
//        new AsyncTask<String, Void, String>() {
//
//            // OkHttpClient client = new OkHttpClient();
//
//            private Exception exception;
//
//            protected String doInBackground(String... urls) {
//                try {
//
//                    return run(urls[0]);
//
//                } catch (Exception e) {
//                    this.exception = e;
//                    Log.e(TAG, "Exception: " + e);
//                    return null;
//                }
//            }
//
//            protected void onPostExecute(String data) {
//                DribbbleFeed feed = new Gson().fromJson(data, DribbbleFeed.class);
//                caller.onDataLoaded(feed);
//            }
//
//            //			String get(URL url) throws IOException {
////				HttpURLConnection connection = client.open(url);
////				InputStream in = null;
////				try {
////					in = connection.getInputStream();
////					byte[] response = readFully(in);
////					return new String(response, "UTF-8");
////				} finally {
////					if (in != null)
////						in.close();
////				}
////
////			}
////            String run(String url) throws IOException {
////                Request request = new Request.Builder()
////                        .url(url)
////                        .build();
////
////                Response response = client.newCall(request).execute();
////                return response.body().string();
////            }
//
//
//            byte[] readFully(InputStream in) throws IOException {
//                ByteArrayOutputStream out = new ByteArrayOutputStream();
//                byte[] buffer = new byte[1024];
//                for (int count; (count = in.read(buffer)) != -1; ) {
//                    out.write(buffer, 0, count);
//                }
//                return out.toByteArray();
//            }
//
//        }.execute("http://api.dribbble.com/shots/popular?per_page=" + itemsPerPage + "&page=" + page);
}

private void update_zan(int pid, final int position, final TextView tv) {
    RequestParams params = new RequestParams();
    params.put("action", "update_zan");
    params.put("pid", pid);
    params.put("user", user);
    //Toast.makeText(context, pid + "", Toast.LENGTH_SHORT).show();
    AsyncHttpClient client = new AsyncHttpClient();
    client.post(Ip.ip + "/YfriendService/DoGetLunTan", params, new AsyncHttpResponseHandler() {

        @Override
        public void onSuccess(int statusCode, Header[] headers, byte[] responseBody) {
            news.get(position).setIspzan("1");
            news.get(position).setPzan(Integer.parseInt((news.get(position).getPzan())) + 1 + " ");
            tv.setEnabled(true);
        }

        @Override
        public void onFailure(int statusCode, Header[] headers, byte[] responseBody, Throwable error) {
            tv.setEnabled(true);
        }
    });
}

@Override
public void onSuccess(int statusCode, Header[] headers, byte[] response) {
    try {
        String str = new String(response, "UTF-8");
        // JSON Object
        JSONObject obj = new JSONObject(str);
        // When the JSON response has status boolean value assigned with true
        res.setText("Result Found : " + System.getProperty("line.separator") + "First Name: " + obj.get("First_Name") + System.getProperty("line.separator") + "Last Name: " + obj.get("Last_Name") + System.getProperty("line.separator") + "Address: " + (!obj.isNull("Address") ? obj.get("Address") : "") + System.getProperty("line.separator") + "BirthDate: " + obj.get("birthdate"));
    } catch (JSONException e) {
        Toast.makeText(getApplicationContext(), "Error Occured [Server's JSON response might be invalid]!", Toast.LENGTH_LONG).show();
        e.printStackTrace();
    } catch (UnsupportedEncodingException e) {
        e.printStackTrace();
    }
}

private void testGet() {
    String url = "http://www.csdn.net/";
    AAHTestApi.getHtml(url, new AsyncHttpResponseHandler() {

        @Override
        public void onSuccess(int statusCode, Header[] headers, byte[] responseBody) {
            try {
                String result = new String(responseBody, "UTF-8");
                tvShowResult.setText(result);
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void onFailure(int statusCode, Header[] headers, byte[] responseBody, Throwable error) {
            UiUtil.toast(AndroidAsyncHttpDemoActivity.this, "error");
        }
    });
}

@Override
public void onFailure(int statusCode, Header[] headers, String responseString, Throwable throwable) {
    Log.i(TAG, "get-onFailure:" + statusCode);
    if (handler != null) {
        handler.onFailure(responseString);
        handler.onFailure(statusCode, responseString);
        if (context != null) {
            FailureUtils.handleHttpRequest(context, responseString, statusCode, throwable);
        }
    }
}

public void postResioninfo(Context context, String id) {
    RequestParams params = new RequestParams();
    params.put("sectorId", id);
    client.post(context, server_url + "/app/incUseCount", params, new TextHttpResponseHandler() {

        @Override
        public void onFailure(int statusCode, Header[] headers, String responseString, Throwable throwable) {
            Log.d("resion", "fail");
            Log.d("resion", "fail " + statusCode);
        }

        @Override
        public void onSuccess(int statusCode, Header[] headers, String responseString) {
            Log.d("resion", "success1");
            Log.d("resion", "success2 " + responseString);
        }
    });
}

@Override
public String sendPost(SendPostModel model, ProgressListener listener, CancellableTask task) throws Exception {
    UrlPageModel urlModel = new UrlPageModel();
    urlModel.chanName = getChanName();
    urlModel.boardName = model.boardName;
    if (model.threadNumber == null) {
        urlModel.type = UrlPageModel.TYPE_BOARDPAGE;
        urlModel.boardPage = UrlPageModel.DEFAULT_FIRST_PAGE;
    } else {
        urlModel.type = UrlPageModel.TYPE_THREADPAGE;
        urlModel.threadNumber = model.threadNumber;
    }
    String referer = buildUrl(urlModel);
    List<Pair<String, String>> fields = VichanAntiBot.getFormValues(referer, task, httpClient);
    if (task != null && task.isCancelled())
        throw new Exception("interrupted");
    ExtendedMultipartBuilder postEntityBuilder = ExtendedMultipartBuilder.create().setCharset(Charset.forName("UTF-8")).setDelegates(listener, task);
    for (Pair<String, String> pair : fields) {
        if (pair.getKey().equals("spoiler") && !model.custommark)
            continue;
        String val;
        switch(pair.getKey()) {
            case "name":
                val = model.name;
                break;
            case "email":
                val = getSendPostEmail(model);
                break;
            case "subject":
                val = model.subject;
                break;
            case "body":
                val = model.comment;
                break;
            case "password":
                val = model.password;
                break;
            case "spoiler":
                val = "on";
                break;
            default:
                val = pair.getValue();
        }
        if (pair.getKey().equals("file")) {
            if (model.attachments != null && model.attachments.length > 0) {
                postEntityBuilder.addFile(pair.getKey(), model.attachments[0], model.randomHash);
            } else {
                postEntityBuilder.addPart(pair.getKey(), new ByteArrayBody(new byte[0], ""));
            }
        } else {
            postEntityBuilder.addString(pair.getKey(), val);
        }
    }
    String url = getUsingUrl() + "post.php";
    Header[] customHeaders = new Header[] { new BasicHeader(HttpHeaders.REFERER, referer) };
    HttpRequestModel request = HttpRequestModel.builder().setPOST(postEntityBuilder.build()).setCustomHeaders(customHeaders).setNoRedirect(true).build();
    HttpResponseModel response = null;
    try {
        response = HttpStreamer.getInstance().getFromUrl(url, request, httpClient, listener, task);
        if (response.statusCode == 200 || response.statusCode == 400) {
            ByteArrayOutputStream output = new ByteArrayOutputStream(1024);
            IOUtils.copyStream(response.stream, output);
            String htmlResponse = output.toString("UTF-8");
            Matcher errorMatcher = ERROR_PATTERN.matcher(htmlResponse);
            if (errorMatcher.find())
                throw new Exception(errorMatcher.group(1));
        } else if (response.statusCode == 303) {
            for (Header header : response.headers) {
                if (header != null && HttpHeaders.LOCATION.equalsIgnoreCase(header.getName())) {
                    return fixRelativeUrl(header.getValue());
                }
            }
        }
        throw new Exception(response.statusCode + " - " + response.statusReason);
    } finally {
        if (response != null)
            response.release();
    }
}

public void fetchHTTP(Uri uri, final File targetFile) throws FetchLinkException, HttpException {
    if (uri == null || uri.getScheme() == null) {
        throw new IllegalArgumentException("Can't decode link");
    }
    final ArrayList<Throwable> errorArray = new ArrayList<>(1);
    final CountDownLatch signal = new CountDownLatch(1);
    SyncHttpClient client = new SyncHttpClient();
    client.get(uri.toString(), new FileAsyncHttpResponseHandler(targetFile) {

        @Override
        public void onFailure(int statusCode, Header[] headers, Throwable throwable, File file) {
            throwable.printStackTrace();
            errorArray.add(throwable);
            if (file.exists()) {
                file.delete();
            }
            signal.countDown();
        }

        @Override
        public void onSuccess(int statusCode, Header[] headers, File file) {
            signal.countDown();
        }
    });
    try {
        Log.i(TAG, "Fetching link...");
        signal.await();
    } catch (InterruptedException e) {
    }
    if (!errorArray.isEmpty()) {
        StringBuilder s = new StringBuilder();
        for (Throwable e : errorArray) {
            s.append(e.toString().concat("\n"));
        }
        throw new HttpException(s.toString());
    }
}

/**
     * Similar to {@link #getDefaultParams() getDefaultParams}, but returns HTTP headers instead.
     *
     * @param pHeaders existing headers
     * @return new headers by combining existing headers and default headers
     * @throws IllegalStateException if the app property file is not loaded
     */
public static Header[] getDefaultParamsAsHeaders(Header[] pHeaders) {
    JSONObject defaultParams = FH.getDefaultParams();
    ArrayList<Header> headers = new ArrayList<Header>(defaultParams.length());
    for (Iterator<String> it = defaultParams.keys(); it.hasNext(); ) {
        String key = it.next();
        headers.add(new BasicHeader("X-FH-" + key, defaultParams.getString(key)));
    }
    if (pHeaders != null) {
        headers.ensureCapacity(pHeaders.length + 1);
        Collections.addAll(headers, pHeaders);
    }
    return headers.toArray(new Header[headers.size()]);
}

@Override
public void onFailure(int statusCode, Header[] headers, byte[] responseBody, Throwable error) {
    setProgressIndicatorVisible(false);
    if (error instanceof HttpResponseException) {
        switch(((HttpResponseException) error).getStatusCode()) {
            case 401:
                showAlertDialog(getString(R.string.error_authentication_failed));
                break;
            default:
                showError(error.getMessage());
        }
    } else if (error instanceof HttpHostConnectException) {
        Log.e(TAG, "Error connecting to host");
        showError(error.getMessage());
    } else if (error instanceof java.net.UnknownHostException) {
        Log.e(TAG, "Unable to resolve hostname");
        showError(error.getMessage());
    } else if (error instanceof SSLHandshakeException) {
        showError(getString(R.string.error_connection_sslhandshake_failed));
    } else {
        Log.e(TAG, error.getClass().toString());
    }
}

@Override
public void onSuccess(int statusCode, Header[] headers, JSONObject response) {
    if (downloadSnackbar != null) {
        downloadSnackbar.dismiss();
    }
    ArrayList<POI> poiArrayList;
    boolean errorOccurred = true;
    String errorMessage = null;
    boolean isPoiAround = false;
    // We check if the server answered correctly and if there is any POI around
    try {
        errorOccurred = response.getJSONObject("err_check").getBoolean("value");
        if (errorOccurred) {
            errorMessage = response.getJSONObject("err_check").getString("err_msg");
        } else {
            errorOccurred = false;
        }
        if (response.getJSONObject("poi").getInt("nb_poi") == 0) {
            isPoiAround = false;
        } else {
            isPoiAround = true;
        }
    } catch (JSONException e) {
        Log.e(LOG_ERROR, "While downloading " + url + ":" + e.getMessage(), e);
        errorOccurred = true;
        e.printStackTrace();
    }
    if (errorOccurred) {
        UI.openPopUp(mapFragment.getActivity(), getResources().getString(eu.wikijourney.wikijourney.R.string.error_download_api_response_title), errorMessage);
    } else if (!isPoiAround) {
        Log.i(LOG_PROGRESS, "No found for POI for " + url);
        UI.openPopUp(mapFragment.getActivity(), getResources().getString(eu.wikijourney.wikijourney.R.string.error_no_poi_around_title), getResources().getString(eu.wikijourney.wikijourney.R.string.error_no_poi_around));
    } else {
        if (paramMethod == HomeFragment.METHOD_PLACE) {
            JSONObject placeLocationJson = null;
            double placeLat = 0;
            double placeLong = 0;
            try {
                placeLocationJson = response.getJSONObject("user_location");
                placeLat = placeLocationJson.getDouble("latitude");
                placeLong = placeLocationJson.getDouble("longitude");
                Location placeLocation = new Location("test");
                placeLocation.setLatitude(placeLat);
                placeLocation.setLongitude(placeLong);
                drawCurrentLocation(placeLocation);
            } catch (JSONException e) {
                Log.e(LOG_ERROR, "cannot get lat/lon from " + url + ":" + e.getMessage(), e);
                e.printStackTrace();
            }
        }
        poiArrayList = POI.parseApiJson(response, paramMethod, context);
        if (poiArrayList != null && poiArrayList.size() != 0) {
            Map.drawPOI(mapFragment, poiArrayList);
        } else {
            UI.openPopUp(context, getResources().getString(eu.wikijourney.wikijourney.R.string.error_no_poi_around_title), getResources().getString(eu.wikijourney.wikijourney.R.string.error_no_poi_around));
        }
    }
}

protected void getRequest(HttpReadResult result) {
    String method = "getRequest; ";
    // See http://hc.apache.org/httpcomponents-client-ga/tutorial/html/fundamentals.html
    HttpResponse httpResponse = null;
    try {
        boolean stop = false;
        do {
            HttpGet httpGet = newHttpGet(result.getUrl());
            if (result.authenticate) {
                specific.httpApacheSetAuthorization(httpGet);
            }
            httpResponse = specific.httpApacheGetResponse(httpGet);
            StatusLine statusLine = httpResponse.getStatusLine();
            result.statusLine = statusLine.toString();
            result.setStatusCode(statusLine.getStatusCode());
            switch(result.getStatusCode()) {
                case OK:
                case UNKNOWN:
                    HttpEntity entity = httpResponse.getEntity();
                    if (entity != null) {
                        if (result.fileResult != null) {
                            FileUtils.readStreamToFile(entity.getContent(), result.fileResult);
                        } else {
                            result.strResponse = HttpConnectionUtils.readStreamToString(entity.getContent());
                        }
                    }
                    stop = true;
                    break;
                case MOVED:
                    result.appendToLog("statusLine:'" + statusLine + "'");
                    result.redirected = true;
                    result.setUrl(httpResponse.getHeaders("Location")[0].getValue().replace("%3F", "?"));
                    String logMsg3 = "Following redirect to '" + result.getUrl() + "'";
                    MyLog.v(this, method + logMsg3);
                    if (MyLog.isVerboseEnabled()) {
                        StringBuilder message = new StringBuilder(method + "Headers: ");
                        for (Header header : httpResponse.getAllHeaders()) {
                            message.append(header.getName() + ": " + header.getValue() + ";\n");
                        }
                        MyLog.v(this, message.toString());
                    }
                    break;
                default:
                    result.appendToLog("statusLine:'" + statusLine + "'");
                    entity = httpResponse.getEntity();
                    if (entity != null) {
                        result.strResponse = HttpConnectionUtils.readStreamToString(entity.getContent());
                    }
                    stop = result.fileResult == null || !result.authenticate;
                    if (!stop) {
                        result.authenticate = false;
                        result.appendToLog("retrying without authentication");
                        DbUtils.closeSilently(httpResponse);
                        MyLog.v(this, result.toString());
                    }
                    break;
            }
        } while (!stop);
    } catch (IOException e) {
        result.setException(e);
    } catch (IllegalArgumentException e) {
        result.setException(e);
    } finally {
        DbUtils.closeSilently(httpResponse);
    }
}

@Override
public void onSuccess(int statusCode, Header[] headers, JSONObject response) {
    try {
        if (response.has("status") && response.getString("status").equals("ok")) {
            if (response.has("payload")) {
                if (SV.good(baseContext, response.getString("payload"), transactionDetails.purchaseToken)) {
                    showPurchased();
                } else {
                    showError();
                }
            } else {
                showError();
            }
        } else {
            showError();
        }
    } catch (JSONException e) {
        showError();
    }
}

@Override
public void onSuccess(int statusCode, Header[] headers, byte[] response) {
    String resultString;
    if (statusCode == 200) {
        resultString = context.getString(R.string.login_sucessful);
        if (callback != null) {
            callback.onSuccess();
        }
    } else {
        resultString = "Status: " + statusCode;
        if (callback != null) {
            callback.onFail(resultString);
        }
    }
    mBuilder.setContentTitle(context.getString(R.string.app_name)).setContentText(resultString).setSmallIcon(R.drawable.ic_stat_login).setContentIntent(getDefaultPendingIntent(context)).setProgress(0, 0, false).setOngoing(true);
    mNotificationManager.notify(Constant.NOTIFICATION_LOGIN_ID, mBuilder.build());
}

public void doRestRequest(String type) {
    Log.i(TAG, "------ doRestRequest()");
    AsyncHttpClient client = new AsyncHttpClient();
    // curl -X POST
    // https://ACae6e420f425248d6a26948c17a9e2acf:77f8c12cc7b8f8423e5c38b035249166@127.0.0.1:8080
    // /restcomm/2012-04-24/Accounts/ACae6e420f425248d6a26948c17a9e2acf
    // /SMS/Messages -d "To=%2B13216549878" -d "From=%2B19876543212" -d "Body=This is a test from RestComm"
    RequestParams params = new RequestParams();
    params.put("From", "alice");
    String url = "";
    if (type.equals("call")) {
        params.put("To", "client:" + BuildConfig.TEST_RESTCOMM_LOGIN);
        params.put("Url", "https://cloud.restcomm.com/restcomm/demos/hello-world.xml");
        url = "https://" + BuildConfig.TEST_RESTCOMM_ACCOUNT_SID + ":" + BuildConfig.TEST_RESTCOMM_AUTH_TOKEN + "@cloud.restcomm.com/restcomm/2012-04-24/Accounts/" + BuildConfig.TEST_RESTCOMM_ACCOUNT_SID + "/Calls.json";
    } else if (type.equals("message")) {
        // due to a bug in Restcomm (https://github.com/RestComm/Restcomm-Connect/issues/2108) To needs to have the 'client:' part removed
        params.put("To", BuildConfig.TEST_RESTCOMM_LOGIN);
        params.put("Body", smsText);
        url = "https://" + BuildConfig.TEST_RESTCOMM_ACCOUNT_SID + ":" + BuildConfig.TEST_RESTCOMM_AUTH_TOKEN + "@cloud.restcomm.com/restcomm/2012-04-24/Accounts/" + BuildConfig.TEST_RESTCOMM_ACCOUNT_SID + "/SMS/Messages";
    }
    client.post(url, params, new ResponseHandlerInterface() {

        @Override
        public void sendResponseMessage(HttpResponse httpResponse) throws IOException {
        }

        @Override
        public void sendStartMessage() {
        }

        @Override
        public void sendFinishMessage() {
        }

        @Override
        public void sendProgressMessage(long l, long l1) {
        }

        @Override
        public void sendCancelMessage() {
        }

        @Override
        public void sendSuccessMessage(int i, Header[] headers, byte[] bytes) {
            Log.i(TAG, "------ request was handled successfully");
        }

        @Override
        public void sendFailureMessage(int i, Header[] headers, byte[] bytes, Throwable throwable) {
        }

        @Override
        public void sendRetryMessage(int i) {
        }

        @Override
        public URI getRequestURI() {
            return null;
        }

        @Override
        public void setRequestURI(URI uri) {
        }

        @Override
        public Header[] getRequestHeaders() {
            return new Header[0];
        }

        @Override
        public void setRequestHeaders(Header[] headers) {
        }

        @Override
        public boolean getUseSynchronousMode() {
            return false;
        }

        @Override
        public void setUseSynchronousMode(boolean b) {
        }

        @Override
        public boolean getUsePoolThread() {
            return false;
        }

        @Override
        public void setUsePoolThread(boolean b) {
        }

        @Override
        public void onPreProcessResponse(ResponseHandlerInterface responseHandlerInterface, HttpResponse httpResponse) {
            Log.i(TAG, "------ response is about to be processed by the system");
        }

        @Override
        public void onPostProcessResponse(ResponseHandlerInterface responseHandlerInterface, HttpResponse httpResponse) {
            Log.i(TAG, "------ request has been fully sent, handled and finished");
        }

        @Override
        public Object getTag() {
            return null;
        }

        @Override
        public void setTag(Object o) {
        }
    });
}

private List<Header> getNewHeaders(JSONObject token) {
    List<Header> headerList = new ArrayList<Header>();
    if (token != null && (AUTH_MODE == AuthMode.Header || AUTH_MODE == AuthMode.Both))
        headerList.add(new BasicHeader("Authorization", token.optString(JSON_KEY_TOKEN_TYPE) + " " + token.optString(JSON_KEY_ACCESS_TOKEN)));
    return headerList;
}

public synchronized void onIncomingRequest(Address requestThem, Address requestUs, byte[] value) {
    //Log.e( TAG, "onIncomingRequest:" + requestThem);
    SessionInputBuffer inBuf = new MemorySessionInputBuffer(value);
    HttpRequestParser parser = new HttpRequestParser(inBuf, lineParser, requestFactory, params);
    HttpRequest req;
    try {
        req = (HttpRequest) parser.parse();
    } catch (IOException e) {
        throw new RuntimeException(e);
    } catch (HttpException e) {
        e.printStackTrace();
        return;
    }
    String requestMethod = req.getRequestLine().getMethod();
    String uid = req.getFirstHeader("Request-Id").getValue();
    String url = req.getRequestLine().getUri();
    if (requestMethod.equals("OFFER")) {
        debug("incoming OFFER " + url);
        for (Header header : req.getAllHeaders()) {
            debug("incoming header: " + header.getName() + "=" + header.getValue());
        }
        if (!url.startsWith(URI_PREFIX_OTR_IN_BAND)) {
            debug("Unknown url scheme " + url);
            sendResponse(requestUs, requestThem, 400, "Unknown scheme", uid, EMPTY_BODY);
            return;
        }
        if (!req.containsHeader("File-Length")) {
            sendResponse(requestUs, requestThem, 400, "File-Length must be supplied", uid, EMPTY_BODY);
            return;
        }
        int length = Integer.parseInt(req.getFirstHeader("File-Length").getValue());
        if (!req.containsHeader("File-Hash-SHA1")) {
            sendResponse(requestUs, requestThem, 400, "File-Hash-SHA1 must be supplied", uid, EMPTY_BODY);
            return;
        }
        sendResponse(requestUs, requestThem, 200, "OK", uid, EMPTY_BODY);
        String sum = req.getFirstHeader("File-Hash-SHA1").getValue();
        String type = null;
        if (req.containsHeader("Mime-Type")) {
            type = req.getFirstHeader("Mime-Type").getValue();
        }
        debug("Incoming sha1sum " + sum);
        Transfer transfer;
        try {
            transfer = new VfsTransfer(url, type, length, requestUs, requestThem, sum);
        } catch (IOException e) {
            e.printStackTrace();
            return;
        }
        transferCache.put(url, transfer);
        // Handle offer
        // TODO ask user to confirm we want this
        boolean accept = false;
        if (mDataListener != null) {
            try {
                mDataListener.onTransferRequested(url, requestThem.getAddress(), requestUs.getAddress(), transfer.url);
            //callback is now async, via "acceptTransfer" method
            //   if (accept)
            //     transfer.perform();
            } catch (RemoteException e) {
                LogCleaner.error(ImApp.LOG_TAG, "error approving OTRDATA transfer request", e);
            }
        }
    } else if (requestMethod.equals("GET") && url.startsWith(URI_PREFIX_OTR_IN_BAND)) {
        debug("incoming GET " + url);
        ByteArrayOutputStream byteBuffer = new ByteArrayOutputStream();
        int reqEnd;
        try {
            Offer offer = offerCache.get(url);
            if (offer == null) {
                sendResponse(requestUs, requestThem, 400, "No such offer made", uid, EMPTY_BODY);
                return;
            }
            // in case we don't see a response to underlying request, but peer still proceeds
            offer.seen();
            if (!req.containsHeader("Range")) {
                sendResponse(requestUs, requestThem, 400, "Range must start with bytes=", uid, EMPTY_BODY);
                return;
            }
            String rangeHeader = req.getFirstHeader("Range").getValue();
            String[] spec = rangeHeader.split("=");
            if (spec.length != 2 || !spec[0].equals("bytes")) {
                sendResponse(requestUs, requestThem, 400, "Range must start with bytes=", uid, EMPTY_BODY);
                return;
            }
            String[] startEnd = spec[1].split("-");
            if (startEnd.length != 2) {
                sendResponse(requestUs, requestThem, 400, "Range must be START-END", uid, EMPTY_BODY);
                return;
            }
            int start = Integer.parseInt(startEnd[0]);
            int end = Integer.parseInt(startEnd[1]);
            if (end - start + 1 > MAX_CHUNK_LENGTH) {
                sendResponse(requestUs, requestThem, 400, "Range must be at most " + MAX_CHUNK_LENGTH, uid, EMPTY_BODY);
                return;
            }
            File fileGet = new File(offer.getUri());
            long fileLength = -1;
            if (fileGet.exists()) {
                fileLength = fileGet.length();
                FileInputStream is = new FileInputStream(fileGet);
                readIntoByteBuffer(byteBuffer, is, start, end);
                is.close();
            } else {
                java.io.File fileGetExtern = new java.io.File(offer.getUri());
                if (fileGetExtern.exists()) {
                    fileLength = fileGetExtern.length();
                    java.io.FileInputStream is = new java.io.FileInputStream(fileGetExtern);
                    readIntoByteBuffer(byteBuffer, is, start, end);
                    is.close();
                }
            }
            if (mDataListener != null && fileLength != -1) {
                float percent = ((float) end) / ((float) fileLength);
                mDataListener.onTransferProgress(true, offer.getId(), requestThem.getAddress(), offer.getUri(), percent);
                String mimeType = null;
                if (req.getFirstHeader("Mime-Type") != null)
                    mimeType = req.getFirstHeader("Mime-Type").getValue();
                mDataListener.onTransferComplete(true, offer.getId(), requestThem.getAddress(), offer.getUri(), mimeType, offer.getUri());
            }
        } catch (UnsupportedEncodingException e) {
            sendResponse(requestUs, requestThem, 400, "Unsupported encoding", uid, EMPTY_BODY);
            return;
        } catch (IOException e) {
            sendResponse(requestUs, requestThem, 400, "IOException", uid, EMPTY_BODY);
            return;
        } catch (NumberFormatException e) {
            sendResponse(requestUs, requestThem, 400, "Range is not numeric", uid, EMPTY_BODY);
            return;
        } catch (Exception e) {
            sendResponse(requestUs, requestThem, 500, "Unknown error", uid, EMPTY_BODY);
            return;
        }
        byte[] body = byteBuffer.toByteArray();
        //   debug("Sent sha1 is " + sha1sum(body));
        sendResponse(requestUs, requestThem, 200, "OK", uid, body);
    } else {
        debug("Unknown method / url " + requestMethod + " " + url);
        sendResponse(requestUs, requestThem, 400, "OK", uid, EMPTY_BODY);
    }
}

@Override
public void onSuccess(int statusCode, Header[] headers, JSONObject response) {
    // called when response HTTP status is "200 OK"
    onLoopJGetCallComplete.response(response.toString());
    System.out.println("Response GET: " + response.toString());
}

public String getHeader(String name) {
    Header header = request.getFirstHeader(name);
    if (header == null) {
        return null;
    }
    return header.getValue();
}