Java Examples for com.squareup.okhttp.Response

@SuppressWarnings("deprecation")
@Override
public WebResourceResponse shouldInterceptRequest(WebView view, String url) {
    try {
        Response response = getEvernoteHtmlHelper().fetchEvernoteUrl(url);
        WebResourceResponse webResourceResponse = toWebResource(response);
        if (webResourceResponse != null) {
            return webResourceResponse;
        }
    } catch (Exception e) {
        CAT.e(e);
    }
    return super.shouldInterceptRequest(view, url);
}

@SuppressWarnings("deprecation")
@Override
public WebResourceResponse shouldInterceptRequest(WebView view, String url) {
    try {
        Response response = getEvernoteHtmlHelper().fetchEvernoteUrl(url);
        WebResourceResponse webResourceResponse = toWebResource(response);
        if (webResourceResponse != null) {
            return webResourceResponse;
        }
    } catch (Exception e) {
        CAT.e(e);
    }
    return super.shouldInterceptRequest(view, url);
}

@Override
public void run() {
    try {
        Request request = new Request.Builder().url(imageUri).build();
        ImageParserThreadManager manager = ImageParserThreadManager.getInstance(null);
        Response response = manager.getClient().newCall(request).execute();
        byte[] byteArray = response.body().bytes();
        manager.removeRunningTask(this, true, byteArray);
    } catch (Exception ex) {
        ImageParserThreadManager.getInstance(null).removeRunningTask(this, false, null);
    }
}

public static String getUrlAsString(URL paramURL) throws IOException {
    Request request = new Request.Builder().header("User-Agent", USER_AGENT).url(paramURL).build();
    OkHttpClient client = new OkHttpClient();
    client.setConnectTimeout(10, TimeUnit.SECONDS);
    Response response = client.newCall(request).execute();
    return response.body().string();
}

@Override
public void run() {
    try {
        OkHttpClient client = new OkHttpClient();
        client.networkInterceptors().add(new LoggingInterceptor());
        RequestBody requestBody = null;
        MediaType mediaType = MediaType.parse("application/json; charset=utf-8");
        if (mRequest.getStreamedContent() != null) {
            requestBody = new StreamedRequest(mediaType, mRequest);
        } else if (mRequest.getContent() != null) {
            requestBody = RequestBody.create(mediaType, mRequest.getContent());
        }
        if (requestBody == null && (mRequest.getVerb().toString().equals("POST") || mRequest.getVerb().toString().equals("PUT"))) {
            requestBody = RequestBody.create(null, new byte[0]);
        }
        Request request = new Request.Builder().url(mRequest.getUrl().toString()).method(mRequest.getVerb().toString(), requestBody).headers(Headers.of(mRequest.getHeaders())).build();
        Response okResponse = client.newCall(request).execute();
        int status = okResponse.code();
        final ResponseBody responseBody = okResponse.body();
        InputStream stream = null;
        if (responseBody != null) {
            stream = responseBody.byteStream();
        }
        if (stream != null) {
            Closeable closeable = new Closeable() {

                @Override
                public void close() throws IOException {
                    responseBody.close();
                }
            };
            com.microsoft.services.orc.http.Response response = new ResponseImpl(stream, status, okResponse.headers().toMultimap(), closeable);
            mFuture.set(response);
        } else {
            mFuture.set(new EmptyResponse(status, okResponse.headers().toMultimap()));
        }
    } catch (Throwable t) {
        t.printStackTrace();
        mFuture.setException(t);
    }
}

private Response toRestlerResponse(com.squareup.okhttp.Response response, Type returnType) {
    HttpStatus status = new HttpStatus(response.code(), response.message());
    InputStream responseBody;
    try {
        responseBody = response.body().byteStream();
        if (response.code() >= 400 && response.code() < 600) {
            return new FailedResponse(status, toString(responseBody), null);
        }
        TypeReference<Object> tr = new RestlerTypeReference(returnType);
        return new SuccessfulResponse(status, toMultiMap(response.headers()), parseResponseBody(response, tr));
    } catch (IOException e) {
        return new FailedResponse(status, null, e);
    }
}

@Override
public Response intercept(Chain chain) throws IOException {
    Request originalRequest = chain.request();
    if (originalRequest.body() == null || originalRequest.header("Content-Encoding") != null) {
        return chain.proceed(originalRequest);
    }
    Request compressedRequest = originalRequest.newBuilder().header("Content-Encoding", "gzip").method(originalRequest.method(), gzip(originalRequest.body())).build();
    return chain.proceed(compressedRequest);
}

public static AndroidTvBoilerplateService newVineyardService() {
    OkHttpClient client = new OkHttpClient();
    client.interceptors().add(new Interceptor() {

        @Override
        public Response intercept(Chain chain) throws IOException {
            Response response = chain.proceed(chain.request());
            // Catch unauthorised error
            return response;
        }
    });
    HttpLoggingInterceptor interceptor = new HttpLoggingInterceptor();
    interceptor.setLevel(HttpLoggingInterceptor.Level.BODY);
    client.interceptors().add(interceptor);
    Retrofit retrofit = new Retrofit.Builder().baseUrl(AndroidTvBoilerplateService.ENDPOINT).client(client).addConverterFactory(GsonConverterFactory.create()).addCallAdapterFactory(RxJavaCallAdapterFactory.create()).build();
    return retrofit.create(AndroidTvBoilerplateService.class);
}

@Override
public Response intercept(Chain chain) throws IOException {
    String marvelHash = MarvelApiUtils.generateMarvelHash(mApiKey, mApiSecret);
    Request oldRequest = chain.request();
    HttpUrl.Builder authorizedUrlBuilder = oldRequest.httpUrl().newBuilder().scheme(oldRequest.httpUrl().scheme()).host(oldRequest.httpUrl().host());
    authorizedUrlBuilder.addQueryParameter(RestDataSource.PARAM_API_KEY, mApiKey).addQueryParameter(RestDataSource.PARAM_TIMESTAMP, MarvelApiUtils.getUnixTimeStamp()).addQueryParameter(RestDataSource.PARAM_HASH, marvelHash);
    Request newRequest = oldRequest.newBuilder().method(oldRequest.method(), oldRequest.body()).url(authorizedUrlBuilder.build()).build();
    return chain.proceed(newRequest);
}

private Bitmap fetchBitmap(String imageUrl) {
    Request request = new Request.Builder().get().url(imageUrl).build();
    try {
        Response response = client.newCall(request).execute();
        InputStream inputStream = response.body().byteStream();
        try {
            bitmap = BitmapFactory.decodeStream(inputStream);
            this.imageUrl = imageUrl;
            return bitmap;
        } finally {
            inputStream.close();
        }
    } catch (IOException e) {
        return null;
    }
}

private static Response get(String url) throws IOException {
    Request request = new Request.Builder().url(url).addHeader("User-Agent", "jPixelFace dev").get().build();
    Response response = client.newCall(request).execute();
    int responseCode = response.code();
    if (responseCode != 200) {
        LOGGER.info("Request to url finished: {} - Response code: {}", url, responseCode);
    }
    return response;
}

@Override
public void call(Subscriber<? super Topic> subscriber) {
    Request request = new Request.Builder().url("http://www.bilibili.com/index/slideshow.json").build();
    try {
        Response response = new OkHttpClient().newCall(request).execute();
        if (response.isSuccessful()) {
            Topic topic = new Gson().fromJson(response.body().string(), Topic.class);
            subscriber.onNext(topic);
        } else {
            subscriber.onError(new Exception(response.message()));
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

@Override
public void onResponse(Response response) {
    if (response.isSuccessful()) {
        String content;
        final T t;
        try {
            content = response.body().string();
            Gson gson = new Gson();
            t = gson.fromJson(content, mType);
            mHandler.post(new Runnable() {

                @Override
                public void run() {
                    onResponse(t);
                }
            });
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

@Override
public Response intercept(Chain chain) throws IOException {
    Request originalRequest = chain.request();
    GenericUrl requestUrl = new GenericUrl(originalRequest.urlString());
    oAuthParams.computeNonce();
    oAuthParams.computeTimestamp();
    try {
        oAuthParams.computeSignature("GET", requestUrl);
        Request compressedRequest = originalRequest.newBuilder().header("Authorization", oAuthParams.getAuthorizationHeader()).header("Accept", "application/xml").method(originalRequest.method(), originalRequest.body()).build();
        return chain.proceed(compressedRequest);
    } catch (GeneralSecurityException e) {
    }
    return chain.proceed(originalRequest);
}

public static Patchboard discover(String url) throws IOException {
    Request.Builder builder = new Request.Builder().url(url);
    builder.header("Accept", "application/json");
    Request request = builder.build();
    Response response = httpClient.newCall(request).execute();
    JsonObject definitionJson = new JsonParser().parse(response.body().string()).getAsJsonObject();
    Definition definition = Definition.parse(definitionJson);
    return new Patchboard(definition);
}

public Interceptor getCacheControlInterceptor(final long age) {
    return new Interceptor() {

        @Override
        public Response intercept(Interceptor.Chain chain) throws IOException {
            Response originalResponse = chain.proceed(chain.request());
            return originalResponse.newBuilder().header("Cache-Control", "max-age=" + age).build();
        }
    };
}

@Override
public Response intercept(Chain chain) throws IOException {
    String token = getAccessToken();
    Request.Builder builder = chain.request().newBuilder();
    Response response;
    try {
        response = chain.proceed(builder.build());
    } catch (IOException e) {
        throw RetrofitError.networkError(e.getLocalizedMessage(), e);
    } catch (Throwable e) {
        throw RetrofitError.unexpectedError(e.getLocalizedMessage(), e);
    }
    if (response.code() == 401) {
        synchronized (lockObject) {
            String currentToken = getAccessToken();
            if (currentToken != null && currentToken.equals(token)) {
                return performRefresh(chain, builder);
            }
        }
    }
    return response;
}

@Override
public Map<String, Set<String>> execute(ListReportParamsCommand command) throws IOException, HttpException {
    String path = String.format("rest_v2/reports%s/inputControls/values", command.getReportUri());
    HttpUrl url = HttpUrl.parse(mBaseUrl + path).newBuilder().addQueryParameter("freshData", "true").build();
    Response response = performRequest(url);
    Map<String, Set<String>> params = new HashMap<>();
    mapResponse(response, params);
    return Collections.unmodifiableMap(params);
}

@Override
public com.squareup.okhttp.Response intercept(Chain chain) throws IOException {
    L.i(TAG, "------getStringRetrofitInstance intercept start-------");
    Request request = chain.request();
    GitHubAccount gitHubAccount = GitHubAccount.getInstance(context);
    token = gitHubAccount.getAuthToken();
    //此处build之��返回request覆盖
    request = request.newBuilder().addHeader("Authorization", "Token " + token).addHeader("User-Agent", "Leaking/1.0").addHeader(//.addHeader("Accept", "application/vnd.github.beta+json")
    "Accept", "application/vnd.github.v3.raw").build();
    // L.i(TAG, "Interceptor header = " + request.headers());
    L.i(TAG, "Interceptor token = " + token);
    L.i(TAG, "Interceptor request = " + request.toString());
    L.i(TAG, "------getStringRetrofitInstance intercept end-------");
    return chain.proceed(request);
}

static RestResponse call(String url, Function<OkHttpClient, OkHttpClient> configureClient, Function<Request.Builder, Request.Builder> configureRequest) throws IOException {
    CookieManager cookieManager = new CookieManager();
    cookieManager.setCookiePolicy(ACCEPT_ALL);
    Request.Builder request = configureRequest.apply(new Request.Builder().url(url));
    OkHttpClient client = configureClient.apply(new OkHttpClient().setCookieHandler(cookieManager));
    Response response = client.newCall(request.build()).execute();
    return new RestResponse(cookieManager, response);
}

@Override
public void call(Subscriber<? super Response> subscriber) {
    try {
        Request request = new Request.Builder().url(url).header("User-Agent", "Mozilla/5.0 (Windows NT 6.3; WOW64)").build();
        subscriber.onNext(mClient.newCall(request).execute());
        subscriber.onCompleted();
    } catch (Throwable e) {
        subscriber.onError(e);
    }
}

public static byte[] get(final String urlString) {
    InputStream in = null;
    try {
        final String decodedUrl = URLDecoder.decode(urlString, "UTF-8");
        final URL url = new URL(decodedUrl);
        final Request request = new Request.Builder().url(url).build();
        final Response response = client.newCall(request).execute();
        in = response.body().byteStream();
        return IOUtils.toByteArray(in);
    } catch (final MalformedURLException e) {
        Log.d(TAG, "Malformed URL", e);
    } catch (final OutOfMemoryError e) {
        Log.d(TAG, "Out of memory", e);
    } catch (final UnsupportedEncodingException e) {
        Log.d(TAG, "Unsupported encoding", e);
    } catch (final IOException e) {
        Log.d(TAG, "IO exception", e);
    } finally {
        if (in != null) {
            try {
                in.close();
            } catch (final IOException ignored) {
            }
        }
    }
    return null;
}

@Override
public void onResponse(Response response) throws IOException {
    Timber.d("onSuccess %d (cache: %s network: %s)", response.code(), response.cacheResponse(), response.networkResponse());
    if (response.isSuccessful() && response.networkResponse() != null && response.networkResponse().code() != HttpURLConnection.HTTP_NOT_MODIFIED) {
        List<FeedEntry> summaries = RssFeedParser.parseFeed(response.body().byteStream());
        DataProviderHelper helper = getDataProviderHelper();
        List<FeedEntry> added = helper.insertFeedEntry(summaries);
        getNotificationManger().sendFeedUpdatedNotification(added);
        getPrecacheHelper().precache(summaries);
    }
    afterCallback();
}

@Override
public InputStream loadData(Priority priority) throws Exception {
    Request.Builder requestBuilder = new Request.Builder().url(url.toStringUrl());
    for (Map.Entry<String, String> headerEntry : url.getHeaders().entrySet()) {
        String key = headerEntry.getKey();
        requestBuilder.addHeader(key, headerEntry.getValue());
    }
    Request request = requestBuilder.build();
    Response response = client.newCall(request).execute();
    responseBody = response.body();
    if (!response.isSuccessful()) {
        throw new IOException("Request failed with code: " + response.code());
    }
    long contentLength = responseBody.contentLength();
    stream = ContentLengthInputStream.obtain(responseBody.byteStream(), contentLength);
    return stream;
}

public void execute() {
    try {
        Response response = mClient.newCall(mRequest).execute();
        mResponseHandler.sendStart();
        int code = response.code();
        String responseString = "without response body";
        if (response.body() != null)
            responseString = response.body().string();
        if (response.isSuccessful())
            mResponseHandler.sendSuccess(code, responseString);
        else
            mResponseHandler.sendFailure(code, responseString);
    } catch (IOException e) {
        String error = "unknown";
        if (e.getMessage() != null)
            error = e.getMessage();
        if (error.equals("Canceled"))
            mResponseHandler.sendCancel();
        else
            mResponseHandler.sendFailure(0, error);
    }
}

public static BasicMessage<List> getUserVideoList(int uid, int page) {
    String url = ApiHelper.getUserVideoListUrl(uid, page);
    Request request = new Request.Builder().url(url).header("User-Agent", ApiHelper.COMMON_UA_STR).build();
    Log.i(TAG, "Set up the request" + request.toString());
    BasicMessage<List> msg = new BasicMessage<>();
    try {
        Response response = new OkHttpClient().newCall(request).execute();
        Log.i(TAG, "Get response:" + response.code());
        String result = response.body().string();
        Log.i(TAG, result);
        msg.setObject(List.createFromJson(result));
        msg.setCode(BasicMessage.CODE_SUCCEED);
    } catch (IOException e) {
        e.printStackTrace();
        msg.setCode(BasicMessage.CODE_ERROR);
    }
    return msg;
}

@Override
public boolean upload(URI uri, String content, String mediaType, Optional<UUID> apiKey, Trial trial) {
    HttpUrl url = HttpUrl.get(uri);
    if (apiKey.isPresent()) {
        url = url.newBuilder().addQueryParameter("key", apiKey.get().toString()).build();
    }
    RequestBody body = RequestBody.create(MediaType.parse(mediaType), content);
    Request request = new Request.Builder().url(url).post(body).build();
    try {
        Response response = client.newCall(request).execute();
        if (response.isSuccessful()) {
            return true;
        } else {
            ResultsUploader.logger.fine("Failed upload response: " + response.code());
        }
    } catch (IOException e) {
        ResultsUploader.logUploadFailure(trial, e);
    }
    return false;
}

@Override
protected Void doInBackground(Void... params) {
    Request request = new Request.Builder().url(url).build();
    Response response;
    try {
        OkHttpClient okHttpClient = new OkHttpClient();
        response = okHttpClient.newCall(request).execute();
        BufferedSink sink = Okio.buffer(Okio.sink(this.output));
        sink.writeAll(response.body().source());
        sink.close();
        Log.d(TAG, "downloaded file " + url + " to " + this.output);
    } catch (IOException e) {
        e.printStackTrace();
        Log.e(TAG, "failed to download file " + url);
    }
    return null;
}

@Test
public void testLoginWithMalformedCredSyntaxThrowsAppropriateError() {
    Response resp = post("/login", "{'user': 'admin', 'pass': 'admin'}");
    JsonObject body = (JsonObject) bodyAsJson(resp);
    Assert.assertEquals(resp.code(), BadLoginSyntaxError.INSTANCE.getCode());
    Assert.assertEquals(body.get("error").getAsString(), BadLoginSyntaxError.INSTANCE.getMessage());
}

@Override
public Response intercept(Chain chain) throws IOException {
    Request originalRequest = chain.request();
    if (originalRequest.body() == null || originalRequest.header("Content-Encoding") != null) {
        return chain.proceed(originalRequest);
    }
    Request compressedRequest = originalRequest.newBuilder().header("Content-Encoding", "gzip").method(originalRequest.method(), requestBodyWithContentLength(gzip(originalRequest.body()))).build();
    return chain.proceed(compressedRequest);
}

@Override
protected ResultType doInBackground(Void... params) {
    final OkHttpClient okHttpClient = App.components().okHttpClient();
    final ProgressListener progressListener = new ProgressListener() {

        @Override
        public void update(long bytesRead, long contentLength) {
            publishProgress((int) ((100 * bytesRead) / contentLength));
        }
    };
    RequestBody requestBody = new MultipartBuilder().type(MultipartBuilder.FORM).addFormDataPart("data", ownLocationModel.getLocationJson().toString()).addFormDataPart("uploaded_file", imageFileToUpload.getName(), new ProgressRequestBody(RequestBody.create(MediaType.parse("image/jpeg"), imageFileToUpload), progressListener)).build();
    Request request = new Request.Builder().url(Endpoints.IMAGE_POST).post(requestBody).build();
    Response response = null;
    try {
        response = okHttpClient.newCall(request).execute();
        if (response.isSuccessful() && response.body().string().equals("success")) {
            return ResultType.SUCCEEDED;
        }
    } catch (Exception ignored) {
    } finally {
        if (response != null) {
            try {
                response.body().close();
            } catch (IOException ignored) {
            }
        }
    }
    return ResultType.FAILED;
}

@Override
protected void onHandleIntent(Intent i) {
    Request request = new Request.Builder().url(i.getData().toString()).build();
    try {
        Response response = BackupService.OKHTTP_CLIENT.newCall(request).execute();
        File toRestore = new File(getCacheDir(), "backup.zip");
        if (toRestore.exists()) {
            toRestore.delete();
        }
        BufferedSink sink = Okio.buffer(Okio.sink(toRestore));
        sink.writeAll(response.body().source());
        sink.close();
        ZipUtils.unzip(toRestore, getFilesDir(), BackupService.ZIP_PREFIX_FILES);
        ZipUtils.unzip(toRestore, BackupService.getSharedPrefsDir(this), BackupService.ZIP_PREFIX_PREFS);
        ZipUtils.unzip(toRestore, getExternalFilesDir(null), BackupService.ZIP_PREFIX_EXTERNAL);
        EventBus.getDefault().post(new RestoreCompletedEvent());
    } catch (Exception e) {
        Log.e(getClass().getSimpleName(), "Exception restoring backup", e);
        EventBus.getDefault().post(new RestoreFailedEvent());
    }
}

@Override
public void call(Subscriber<? super String> subscriber) {
    if (!subscriber.isUnsubscribed()) {
        FormEncodingBuilder builder = new FormEncodingBuilder();
        builder.add("url", add2GankBean.getUrl());
        builder.add("desc", add2GankBean.getDesc());
        builder.add("who", add2GankBean.getWho());
        builder.add("type", add2GankBean.getType());
        builder.add("debug", "true");
        RequestBody body = RequestBody.create(JSON, new Gson().toJson(new TestAlyCreateClassBean()));
        Request request = new Request.Builder().url(CREATE_CLASS_URL).post(/*builder.build()*/
        body).build();
        mOkHttpClient.newCall(request).enqueue(new Callback() {

            @Override
            public void onFailure(Request request, IOException e) {
                subscriber.onError(e);
            }

            @Override
            public void onResponse(Response response) throws IOException {
                if (response.isSuccessful()) {
                    subscriber.onNext(response.body().string());
                    subscriber.onCompleted();
                } else {
                    subscriber.onError(new Exception(response.message()));
                }
            }
        });
    }
}

@Override
public Response intercept(Chain chain) throws IOException {
    final Request original = chain.request();
    if (original.body() == null || original.header("Content-Encoding") != null) {
        return chain.proceed(original);
    }
    Request gzip = original.newBuilder().header("Content-Encoding", "gzip").method(original.method(), new RequestBody() {

        @Override
        public MediaType contentType() {
            return original.body().contentType();
        }

        @Override
        public long contentLength() throws IOException {
            return -1;
        }

        @Override
        public void writeTo(BufferedSink sink) throws IOException {
            BufferedSink gzipper = Okio.buffer(new GzipSink(sink));
            original.body().writeTo(gzipper);
            gzipper.close();
        }
    }).build();
    return chain.proceed(gzip);
}

@Override
protected Boolean doInBackground(Void... params) {
    Request request = new Request.Builder().url(mContext.getString(R.string.api_url) + "/productMap/productMap.html").build();
    try {
        Response response = mHttpClient.newCall(request).execute();
        FileOutputStream fos = mContext.openFileOutput("productMap.html", Context.MODE_PRIVATE);
        fos.write(response.body().string().getBytes());
        fos.close();
    } catch (IOException e) {
        Log.e(TAG, "Failed to fetch map", e);
        return false;
    }
    return true;
}

public static byte[] get(final String urlString) {
    InputStream in = null;
    try {
        final String decodedUrl = URLDecoder.decode(urlString, "UTF-8");
        final URL url = new URL(decodedUrl);
        final Request request = new Request.Builder().url(url).build();
        final Response response = client.newCall(request).execute();
        in = response.body().byteStream();
        return IOUtils.toByteArray(in);
    } catch (final MalformedURLException e) {
        Log.d(TAG, "Malformed URL", e);
    } catch (final OutOfMemoryError e) {
        Log.d(TAG, "Out of memory", e);
    } catch (final UnsupportedEncodingException e) {
        Log.d(TAG, "Unsupported encoding", e);
    } catch (final IOException e) {
        Log.d(TAG, "IO exception", e);
    } finally {
        if (in != null) {
            try {
                in.close();
            } catch (final IOException ignored) {
            }
        }
    }
    return null;
}

private Interceptor getInterceptor() {
    return new Interceptor() {

        @Override
        public Response intercept(Chain chain) throws IOException {
            Request request = chain.request();
            if (!Utils.isNetworkAvailable(Application.mContext)) {
                request = request.newBuilder().cacheControl(CacheControl.FORCE_CACHE).build();
            }
            return chain.proceed(request);
        }
    };
}

@Test
public void failWithoutTenantHeader() throws Throwable {
    /* First make sure inventory has started through checking the test env is there
         * This also ensures that the access is granted with the tenantId set by newAuthRequest() */
    String path = "/hawkular/inventory/entity/e;" + testEnvId;
    Environment env = getWithRetries(path, Environment.class, 10, 2000);
    assertEquals("Unable to get the '" + testEnvId + "' environment.", testEnvId, env.getId());
    /* Now do the same without the tenantId header */
    String url = baseURI + path;
    Request request = //
    new Request.Builder().addHeader("Authorization", //
    authHeader).addHeader("Accept", //
    "application/json").url(url).build();
    Response response = client.newCall(request).execute();
    assertEquals("Accessing Inventory without Hawkular-Tenant header should not be possible.", 400, response.code());
}

/**
	 * Activate link
	 * @param link activation url
	 * @return true if activation successfull
	 */
public boolean activateLink(String link) {
    try {
        Request request = new Request.Builder().url(link).build();
        Response response = client.newCall(request).execute();
        String strResponse = response.body().string();
        if (strResponse.contains(SUCCESS_MSG)) {
            logger.info("Activation success");
            return true;
        }
        if (strResponse.contains(ALREADY_DONE_MSG)) {
            logger.info("Activation already done");
            return true;
        }
        if (strResponse.contains(INVALID_TOKEN_MSG)) {
            logger.error("Invalid Activation token");
            return false;
        }
        logger.error("Unexpected Error");
        return false;
    } catch (IOException e) {
        return false;
    }
}

@Override
public Request authenticate(Proxy proxy, Response response) throws IOException {
    Log.d(TAG, "Calling ApiAuthenticator.authenticate");
    // Do not try to authenticate oauth related paths
    if (response.request().uri().getPath().startsWith("/oauth"))
        return null;
    Account account = AuthUtils.getActiveAccount(appContext, accountType);
    if (account == null) {
        failAuth();
        return null;
    }
    String oldToken = accountManager.peekAuthToken(account, authtokenType);
    if (oldToken != null) {
        Log.d(TAG, "Invalidating auth token.");
        accountManager.invalidateAuthToken(accountType, oldToken);
    }
    try {
        Log.d(TAG, "calling accountManager.blockingGetAuthToken");
        String token = accountManager.blockingGetAuthToken(account, authtokenType, false);
        if (token == null) {
            accountManager.removeAccount(account, null, null, null);
            failAuth();
            return null;
        } else {
            return response.request().newBuilder().header("Authorization", "Bearer " + token).build();
        }
    } catch (Exception e) {
        Log.e(TAG, "Failed to retrieve auth token.", e);
    }
    return null;
}

@Override
public Response intercept(Chain chain) throws IOException {
    Response originalResponse = chain.proceed(chain.request());
    // Logger.d("PREPAID COOKIE**" + originalResponse.header("prepaiduser-payauth"));
    if (!originalResponse.headers("Set-Cookie").isEmpty()) {
        HashSet<String> cookies = new HashSet<>();
        for (String header : originalResponse.headers("Set-Cookie")) {
            if (header.contains(Constants.HEADER_PREPAID_COOKIE)) {
                Logger.d("PREPAID COOKIE**" + header);
                EventBus.getDefault().post(new CookieEvents(header));
            }
        }
    } else {
        EventBus.getDefault().post(new CookieEvents(null));
    }
    RetroFitClient.removeInterCeptor();
    return originalResponse;
}

private static void createOKClient() {
    //Set globant Proxy for make API calls inside Globant Company
    //TODO: Change the location of this code
    //System.setProperty("http.proxyHost", "proxy.corp.globant.com");
    //System.setProperty("http.proxyPort", "3128");
    okClient = new OkHttpClient();
    okClient.interceptors().add(new Interceptor() {

        @Override
        public Response intercept(Chain chain) throws IOException {
            Response response = chain.proceed(chain.request());
            return response;
        }
    });
}

/** 実際�通信処�を行� */
protected void execute(Request req) {
    mResponseObj = null;
    mResponseBodyText = null;
    mResponseStatusCode = -1;
    OkHttpClient client = new OkHttpClient();
    ResponseBody body = null;
    try {
        Response res = client.newCall(req).execute();
        mResponseStatusCode = res.code();
        body = res.body();
        if (isResponseOk(res)) {
            mResponseBodyText = body.string();
        } else {
            Timber.e("execute: failed request code=" + res.code());
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (body != null) {
            try {
                body.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

public void handleResult(Uri data) {
    if (data == null)
        return;
    String code = data.getQueryParameter("code");
    if (code == null)
        return;
    try {
        // Trade our code for an access token.
        Request request = //
        new Request.Builder().url(//
        "https://github.com/login/oauth/access_token").header("Accept", //
        "application/json").post(//
        new FormEncodingBuilder().add("client_id", //
        CLIENT_ID).add("client_secret", //
        CLIENT_SECRET).add("code", //
        code).build()).build();
        Response response = client.newCall(request).execute();
        if (response.isSuccessful()) {
            AccessTokenResponse accessTokenResponse = moshi.adapter(AccessTokenResponse.class).fromJson(response.body().string());
            if (accessTokenResponse != null && accessTokenResponse.access_token != null) {
                accessToken.set(accessTokenResponse.access_token);
            }
        }
    } catch (IOException e) {
        Timber.w(e, "Failed to get access token.");
    }
}

@Override
public final void register(final Robot robot) {
    robot.respond("(?i)lgtm\\z", "fetching an image from www.lgtm.in.",  message -> {
        final OkHttpClient client = new OkHttpClient();
        final String url = "https://www.lgtm.in/g";
        final Request request = new Request.Builder().url(url).header("Accept", "application/json").build();
        try {
            final TrustManager[] trustManagers = new TrustManager[] { new X509TrustManager() {

                @Override
                public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
                }

                @Override
                public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
                }

                @Override
                public X509Certificate[] getAcceptedIssuers() {
                    return null;
                }
            } };
            final SSLContext sslContext = SSLContext.getInstance("SSL");
            sslContext.init(null, trustManagers, new java.security.SecureRandom());
            final SSLSocketFactory sslSocketFactory = sslContext.getSocketFactory();
            final Response response = client.setSslSocketFactory(sslSocketFactory).newCall(request).execute();
            if (response.isSuccessful()) {
                final String src = response.body().string();
                final JsonObject jsonObject = new Gson().fromJson(src, JsonObject.class);
                final String imageUrl = jsonObject.get("imageUrl").getAsString();
                message.reply(imageUrl);
            } else {
                message.reply(ERROR_PREFIX + String.format("http request failed (%d)", response.code()));
            }
        } catch (Exception e) {
            log.warn(e.getMessage());
            message.reply(ERROR_PREFIX + e.getMessage());
        }
    });
}

public void processHTTPCall(final HttpClientCallback callback) {
    OkHttpClient httpClient = new OkHttpClient();
    Request.Builder requestBuilder = new Request.Builder().url(url);
    Request request = null;
    if (TextUtils.isEmpty(this.method)) {
        this.method = GET;
    }
    switch(this.method) {
        case POST:
            break;
        case PUT:
            break;
        case DELETE:
            break;
        default:
            request = requestBuilder.get().build();
            break;
    }
    try {
        Response response = httpClient.newCall(request).execute();
        if (response.isSuccessful()) {
            if (callback != null) {
                callback.OnHttpComplete(success, response.body().string());
            }
        } else {
            if (callback != null) {
                callback.OnHttpComplete(failure, "'" + response.message() + "'");
            }
        }
    } catch (Exception e) {
        if (callback != null) {
            callback.OnHttpComplete(failure, "'" + e.getMessage() + "'");
        }
    }
}

@Test
public void testStartLoadingLogNoToken() {
    final long jobId = 1L;
    final String expectedUrl = "https://sample.org";
    Response response = new Response(expectedUrl, 200, "", Collections.<Header>emptyList(), null);
    when(mRawClient.getApiService().getLog(String.valueOf(jobId))).thenReturn(response);
    mBuildsDetailsPresenter.startLoadingLog(jobId);
    verify(mTaskManager).getLogUrl(jobId);
    verify(mBuildDetailsView).setLogUrl(expectedUrl);
}

public void get() {
    //get Request
    Request myGetRequest = new Request.Builder().url("https://api.github.com/users/florent37").build();
    okHttpClient.newCall(myGetRequest).enqueue(new Callback() {

        @Override
        public void onFailure(Request request, IOException e) {
        }

        @Override
        public void onResponse(Response response) throws IOException {
            //le retour est effectué dans un thread différent
            final String text = response.body().string();
            final int statusCode = response.code();
            runOnUiThread(new Runnable() {

                @Override
                public void run() {
                    textView.setText(text);
                }
            });
        }
    });
}

@Override
public Response intercept(Chain chain) throws IOException {
    Request request = chain.request();
    Logger.d("---> REQUEST " + request.method() + " " + request.urlString());
    logHeaders(request.headers());
    //copy original request for logging request body
    Request copy = request.newBuilder().build();
    RequestBody requestBody = copy.body();
    if (requestBody == null) {
        Logger.d("Body - no body");
    } else {
        Buffer buffer = new Buffer();
        requestBody.writeTo(buffer);
        Logger.d("Body - " + buffer.readString(requestBody.contentType().charset()));
    }
    Logger.d("---> END");
    long t1 = System.nanoTime();
    Response response = chain.proceed(request);
    long t2 = System.nanoTime();
    Logger.d("<--- RESPONSE " + response.code() + " " + response.request().urlString());
    logHeaders(response.headers());
    String responseBody = response.body().string();
    Logger.d(TextUtils.isEmpty(responseBody) ? "Body - no body" : "Body - " + responseBody);
    Logger.d("<--- END " + "(Size: " + response.body().contentLength() + " bytes - " + "Network time: " + (t2 - t1) / MILLI_AS_NANO + " ms)");
    return response;
}

@Override
public Response intercept(Chain chain) throws IOException {
    Request originalRequest = chain.request();
    HttpUrl newUrl = originalRequest.httpUrl().newBuilder().addQueryParameter("v", BUILD_DATE).addQueryParameter("oauth_token", Preferences.getFoursquareToken()).build();
    Request newRequest = originalRequest.newBuilder().url(newUrl).build();
    L.i("Calling " + newUrl);
    Response response = chain.proceed(newRequest);
    L.i("Response code: " + response.code());
    return response;
}

/**
     * - Execute HTTP request
     * - Extract content from HTTP response
     * - Build HtmlTransformer object
     * - Return a WebPage2HtmlResult object
     *
     * @return WebPage2HtmlResult
     */
public WebPage2HtmlResult execute() throws IOException {
    // If no configuration given, create a default one
    if (configuration == null) {
        configuration = new Configuration();
    }
    // Execute request
    HttpRequest httpRequest = new HttpRequest(requestURL, configuration);
    Response httpResponse = httpRequest.execute();
    URL actualURl = httpResponse.request().httpUrl().url();
    // Extract content and charset
    ResponseBody responseBody = httpResponse.body();
    String content = responseBody.string();
    String charset = null;
    if (responseBody.contentType().charset() instanceof Charset) {
        charset = responseBody.contentType().charset().name();
    }
    // Build HtmlTransformer object and transform
    HtmlTransformer htmlTransformer = new HtmlTransformer(content, actualURl, charset, configuration);
    htmlTransformer.transform();
    // Build a WebPage2HtmlResult object
    WebPage2HtmlResult webPage2HtmlResult = new WebPage2HtmlResult(htmlTransformer);
    return webPage2HtmlResult;
}

public static String doGetRequst(String url) throws IOException {
    if (DEBUG) {
        Log.i(TAG, url);
    }
    Request request = new Request.Builder().url(url).build();
    Response response = client.newCall(request).execute();
    if (response.isSuccessful()) {
        String result = response.body().string();
        if (DEBUG) {
            Log.i(TAG, result);
        }
        return result;
    } else {
        throw new IOException("Unexpected code " + response);
    }
}

@Override
public HttpResponse performRequest(Request<?> request, Map<String, String> additionalHeaders) throws IOException, AuthFailureError {
    OkHttpClient client = mClient.clone();
    int timeoutMs = request.getTimeoutMs();
    client.setConnectTimeout(timeoutMs, TimeUnit.MILLISECONDS);
    client.setReadTimeout(timeoutMs, TimeUnit.MILLISECONDS);
    client.setWriteTimeout(timeoutMs, TimeUnit.MILLISECONDS);
    com.squareup.okhttp.Request.Builder okHttpRequestBuilder = new com.squareup.okhttp.Request.Builder();
    okHttpRequestBuilder.url(request.getUrl());
    Map<String, String> headers = request.getHeaders();
    for (final String name : headers.keySet()) {
        okHttpRequestBuilder.addHeader(name, headers.get(name));
    }
    for (final String name : additionalHeaders.keySet()) {
        okHttpRequestBuilder.addHeader(name, additionalHeaders.get(name));
    }
    setConnectionParametersForRequest(okHttpRequestBuilder, request);
    com.squareup.okhttp.Request okHttpRequest = okHttpRequestBuilder.build();
    Call okHttpCall = client.newCall(okHttpRequest);
    com.squareup.okhttp.Response okHttpResponse = okHttpCall.execute();
    StatusLine responseStatus = new BasicStatusLine(parseProtocol(okHttpResponse.protocol()), okHttpResponse.code(), okHttpResponse.message());
    BasicHttpResponse response = new BasicHttpResponse(responseStatus);
    response.setEntity(entityFromOkHttpResponse(okHttpResponse));
    Headers responseHeaders = okHttpResponse.headers();
    for (int i = 0, len = responseHeaders.size(); i < len; i++) {
        final String name = responseHeaders.name(i), value = responseHeaders.value(i);
        if (name != null) {
            response.addHeader(new BasicHeader(name, value));
        }
    }
    return response;
}

@Override
public void onResponse(Response response) throws IOException {
    try {
        String res = response.body().string();
        JSONObject js = new JSONObject(res).getJSONObject("data");
        String endpoint1 = js.getString("endpoint");
        sharedPreferences.edit().putString("registration_endpoint", endpoint1).putString("registration_data", js.toString()).commit();
        startService(js, context);
        Log.d("ActorPushRegister", "Endpoint: " + endpoint1);
        callback.onRegistered(endpoint1);
    } catch (JSONException e) {
        e.printStackTrace();
    }
}

@Override
public byte[] downloadBitmap(Context context, String url, ImageConfig config) throws Exception {
    Logger.v(url);
    try {
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        DownloadProcess progress = config.getProgress();
        if (progress != null)
            progress.sendPrepareDownload(url);
        Request request = new Request.Builder().url(url).build();
        //			httpGet.addHeader("User-Agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.8; rv:27.0) Gecko/20100101 Firefox/27.0");
        Response response = GlobalContext.getOkHttpClient().newCall(request).execute();
        if (!(response.code() == HttpURLConnection.HTTP_OK || response.code() == HttpURLConnection.HTTP_PARTIAL)) {
            throw new TaskException(String.valueOf(TaskException.TaskError.failIOError));
        } else {
            // 图片大�
            int length = 0;
            try {
                String header = response.header("Content-Length");
                length = Integer.parseInt(header);
            } catch (Exception e) {
            }
            if (progress != null) {
                progress.sendLength(length);
            }
            InputStream in = response.body().byteStream();
            // 获�图片数�
            byte[] buffer = new byte[1024 * 8];
            int readLen = -1;
            int readBytes = 0;
            while ((readLen = in.read(buffer)) != -1) {
                readBytes += readLen;
                if (progress != null)
                    progress.sendProgress(readBytes);
                out.write(buffer, 0, readLen);
            }
            byte[] bs = out.toByteArray();
            // 如果图片没有下载完�，默认图片加载失败
            if (length != 0 && bs.length != length)
                return null;
            in.close();
            out.close();
            return bs;
        }
    } catch (Exception e) {
        e.printStackTrace();
        if (config.getProgress() != null)
            config.getProgress().sendException(e);
        throw new Exception(e.getCause());
    }
}

@Override
public <T> T doGet(HttpConfig config, Setting action, Params urlParams, Class<T> responseCls) throws TaskException {
    if (GlobalContext.getInstance() == null || SystemUtils.getNetworkType(GlobalContext.getInstance()) == SystemUtils.NetWorkType.none)
        return null;
    String url = urlParams.getParameter("path");
    PictureSize size = new PictureSize();
    size.setUrl(url);
    Request request = new Request.Builder().url(url).build();
    try {
        Response response = GlobalContext.getOkHttpClient().newCall(request).execute();
        if (!(response.code() == HttpURLConnection.HTTP_OK || response.code() == HttpURLConnection.HTTP_PARTIAL)) {
            throw new TaskException(String.valueOf(TaskException.TaskError.failIOError));
        } else {
            // 图片大�
            String header = response.header("Content-Length");
            int length = Integer.parseInt(header);
            size.setSize(length);
            SinaDB.getDB().insert(null, size);
            Logger.d(TAG, String.format("图片大� %s", String.valueOf(size.getSize())));
        }
    } catch (Exception e) {
        throw new TaskException(String.valueOf(TaskException.TaskError.failIOError));
    }
    return (T) size;
}

@Override
public HttpResponse execute(String uri) {
    try {
        Request httpRequest = new Request.Builder().url(uri).build();
        Response httpResponse = mClient.newCall(httpRequest).execute();
        return new OkHttpResponse(httpResponse);
    } catch (IOException e) {
        throw new RuntimeException("HTTP execute failed", e);
    }
}

@Override
public void run() {
    log.debug("querying \"{}\"...", url);
    final Request.Builder request = new Request.Builder();
    request.url(url);
    request.header("Accept-Charset", "utf-8");
    if (userAgent != null)
        request.header("User-Agent", userAgent);
    final Call call = Constants.HTTP_CLIENT.newCall(request.build());
    try {
        final Response response = call.execute();
        if (response.isSuccessful()) {
            final long serverTime = response.headers().getDate("Date").getTime();
            final BufferedReader reader = new BufferedReader(response.body().charStream());
            final String line = reader.readLine().trim();
            reader.close();
            handleLine(line, serverTime);
        }
    } catch (final Exception x) {
        handleException(x);
    }
}

@Override
protected void onHandleIntent(Intent intent) {
    DatabaseManager databaseManager = new DatabaseManager(this);
    Gson gson = new Gson();
    Request request = new Request.Builder().url("http://xkcd.com/info.0.json").build();
    try {
        Response response = BlipApplication.getInstance().client.newCall(request).execute();
        if (!response.isSuccessful())
            throw new IOException();
        String responseBody = response.body().string();
        if (responseBody.substring(0, 1).equals("{")) {
            Comic comic = gson.fromJson(responseBody, Comic.class);
            if (!databaseManager.comicExists(comic)) {
                databaseManager.addComic(comic);
                Intent notifIntent = new Intent(NEW_COMIC);
                notifIntent.putExtra(EXTRA_NUM, comic.getNum());
                sendBroadcast(notifIntent);
            }
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

public static String getStringFromServer(String url) throws IOException {
    Request request = new Request.Builder().url(url).build();
    Response response = execute(request);
    if (response.isSuccessful()) {
        String responseUrl = response.body().string();
        return responseUrl;
    } else {
        throw new IOException("Unexpected code " + response);
    }
}

@Test
public void proxy() throws Exception {
    server.enqueue(new MockResponse().setBody("abc"));
    server.enqueue(new MockResponse().setBody("def"));
    OkHttpClient client = new OkHttpClient().setProxy(socksProxy.proxy());
    Request request1 = new Request.Builder().url(server.url("/")).build();
    Response response1 = client.newCall(request1).execute();
    assertEquals("abc", response1.body().string());
    Request request2 = new Request.Builder().url(server.url("/")).build();
    Response response2 = client.newCall(request2).execute();
    assertEquals("def", response2.body().string());
    // The HTTP calls should share a single connection.
    assertEquals(1, socksProxy.connectionCount());
}

@Override
public void call(Subscriber<? super ShelterStatuses> subscriber) {
    final ApiMethod apiMethod = mApi.downloadStatuses();
    try {
        final Request request = new Request.Builder().url(apiMethod.getUrl()).get().build();
        final Response response = mClient.newCall(request).execute();
        final String result = response.body().string();
        final ShelterStatuses statuses = ShelterFactory.createStatuses(result);
        subscriber.onNext(statuses);
        subscriber.onCompleted();
    } catch (IOExceptionJSONException | ParseException |  e) {
        Log.e(TAG, ExceptionUtils.getStackTrace(e));
        subscriber.onError(e);
    }
}

private Bitmap requestForBitmapByUrl() {
    try {
        OkHttpClient client = new OkHttpClient();
        Request request = new Request.Builder().url(thumbnailUrl).build();
        Response response = client.newCall(request).execute();
        return BitmapFactory.decodeStream(response.body().byteStream());
    } catch (IOException e) {
        Log.e(TAG, e.getMessage());
        return null;
    }
}

@Override
public void onResponse(Response response) throws IOException {
    responseBody = response.body();
    if (response.isSuccessful()) {
        long contentLength = responseBody.contentLength();
        stream = ContentLengthInputStream.obtain(responseBody.byteStream(), contentLength);
    } else if (Log.isLoggable(TAG, Log.DEBUG)) {
        Log.d(TAG, "OkHttp got error response: " + response.code() + ", " + response.message());
    }
    callback.onDataReady(stream);
}

@Override
protected Boolean doInBackground(Void... params) {
    OkHttpClient client = new OkHttpClient();
    Request request = new Request.Builder().url(Constants.SCHEDULE_URL).build();
    try {
        Response response = client.newCall(request).execute();
        Schedule schedule = new Schedule(context);
        // Parse JSON and add it to SQLite DB
        schedule.updateSchedule(response.body().string());
        // successfully updated schedule
        return true;
    } catch (IOExceptionJSONException |  e) {
        e.printStackTrace();
    }
    // failed to update schedule
    return false;
}

@Override
protected void onHandleIntent(Intent intent) {
    synchronized (SERVICE_LOCK) {
        try {
            try {
                final URL source = new URL(intent.getStringExtra(EXTRA_SOURCE_URL));
                final String tableName = intent.getStringExtra(EXTRA_TABLE_NAME);
                final List<FeedArticle> remainders = new ArrayList<>();
                Response resp;
                JSONArray array;
                try {
                    resp = NetworkOperations.performGETRequest(source);
                    if (resp.code() == SERVER_UPDATING_STATUS_CODE)
                        throw new IOException("Server is updating");
                    array = new JSONArray(resp.body().string());
                } catch (IOException e) {
                    return;
                }
                for (int i = 0; i < array.length(); i++) {
                    final JSONObject obj = array.getJSONObject(i);
                    FeedArticle thisArticle = new FeedArticle(Html.fromHtml(obj.getString(KEY_TITLE)).toString(), obj.getString(KEY_CONTENT_URL), obj.getString(KEY_IMG_URL), Html.fromHtml(obj.getString(KEY_CONTENT)).toString(), Boolean.FALSE);
                    if (!remainders.contains(thisArticle))
                        remainders.add(thisArticle);
                }
                Collections.reverse(remainders);
                SQLiteDAO.getInstance().insertArticlesIntoTable(remainders, tableName);
            } catch (MalformedURLException e) {
                throw new IllegalArgumentException("Source url " + intent.getStringExtra(EXTRA_SOURCE_URL) + " is malformed.");
            } catch (JSONException e) {
            }
        } catch (Exception e) {
        }
    }
}

@Override
public void onResponse(Response response) throws IOException {
    String responseStr = response.body().string();
    final String messageText = "Status code : " + response.code() + "\n" + "Response body : " + responseStr;
    runOnUiThread(new Runnable() {

        @Override
        public void run() {
            Toast.makeText(getApplicationContext(), messageText, Toast.LENGTH_LONG).show();
        }
    });
}

String getResponseJson(PullRequestUrl id) {
    Request request = new Request.Builder().url(id.apiAddress()).addHeader("User-Agent", "OkHttpClient/1.0 (Make Open Easy repository sync software)").build();
    try {
        Response response = client.newCall(request).execute();
        if (!response.isSuccessful()) {
            switch(response.code()) {
                case 404:
                    throw new InvalidGithubUrl("No such pull request found: %s", id);
                case 403:
                    throw new InvalidGithubUrl("Github rate-limit reached - please wait 60 mins: %s", id);
                default:
                    throw new IOException("Unexpected code " + response);
            }
        }
        return response.body().string();
    } catch (IOException ioe) {
        throw new RuntimeException(ioe);
    }
}

@Override
public void run() {
    try {
        sendRequest();
        Response response = readResponse();
        responseReceiver.onResponse(response);
    } catch (IOException e) {
        responseReceiver.onFailure(new Failure.Builder().request(request).exception(e).build());
    } finally {
        connection.disconnect();
        dispatcher.finished(this);
    }
}

private String getJSONDirection(LatLng start, LatLng end, TravelMode mode) throws IOException {
    String url = "http://maps.googleapis.com/maps/api/directions/json?" + "origin=" + start.latitude + "," + start.longitude + "&destination=" + end.latitude + "," + end.longitude + "&sensor=false&units=metric&mode=" + mode.name().toLowerCase();
    Request request = new Request.Builder().url(url).build();
    Response response = client.newCall(request).execute();
    return response.body().string();
}

// Downloads data from a url and returns it as an input stream
private static InputStream downloadUrl(String url) {
    if (okHttpClient == null) {
        okHttpClient = new OkHttpClient();
    }
    Request request = new Request.Builder().url(url).build();
    try {
        Response response = okHttpClient.newCall(request).execute();
        return response.body().byteStream();
    } catch (IOException e) {
        Log.e(TAG, e.toString(), e);
    }
    return null;
}

@Test
public void matchCustomResponse() throws Exception {
    TestSubscriber<Response> subscriber = request("/hello");
    rxDispatcher.match(new RxDispatcher.Response() {

        @Override
        public boolean match(HttpServerRequest<ByteBuf> request) {
            return true;
        }

        @Override
        public void process(HttpServerResponse<ByteBuf> response) {
            response.setStatus(HttpResponseStatus.OK);
            response.writeString("world");
        }
    });
    matchesBody(subscriber, "world");
}

@Override
public void onResponse(Response response) throws IOException {
    String body = response.body().string();
    Log.d("Chart", body);
    try {
        JSONObject jObj = new JSONObject(body);
        JSONArray jRes = jObj.getJSONArray("results");
        for (int i = 0; i < jRes.length(); i++) {
            JSONObject obj = jRes.getJSONObject(i);
            Value val = new Value();
            val.timestamp = obj.getLong("timestamp");
            val.value = (float) obj.getDouble("value");
            results.add(val);
        }
        listener.onDataReady(results);
    } catch (JSONException jse) {
        jse.printStackTrace();
    }
}

@Override
public Response intercept(Chain chain) throws IOException {
    Request request = chain.request();
    if (!StringUtils.isEmpty(config.getApiKey())) {
        request = request.newBuilder().addHeader(SyncthingApi.HEADER_API_KEY, StringUtils.trim(config.getApiKey())).build();
    } else if (!StringUtils.isEmpty(config.getAuth())) {
        request = request.newBuilder().addHeader("Authorization", StringUtils.trim(config.getAuth())).build();
    }
    if (config.isDebug()) {
        Timber.d(request.toString());
        if (StringUtils.equalsIgnoreCase(request.method(), "POST")) {
            Buffer buffer = new Buffer();
            request.body().writeTo(buffer);
            ByteString content = buffer.snapshot();
            Timber.d("body=%s", buffer.readString(Charset.defaultCharset()));
            MediaType type = request.body().contentType();
            request = request.newBuilder().post(RequestBody.create(type, content)).build();
        }
    }
    return chain.proceed(request);
}

@Override
public void handleMessage(Message msg) {
    int what = msg.what;
    switch(what) {
        case SUBMIT:
            {
                WXHttpTask task = (WXHttpTask) msg.obj;
                Request.Builder builder = new Request.Builder().header("User-Agent", "WeAppPlusPlayground/1.0").url(task.url);
                WXHttpResponse httpResponse = new WXHttpResponse();
                try {
                    Response response = mOkHttpClient.newCall(builder.build()).execute();
                    httpResponse.code = response.code();
                    httpResponse.data = response.body().bytes();
                    task.response = httpResponse;
                    mUiHandler.sendMessage(mUiHandler.obtainMessage(1, task));
                } catch (Throwable e) {
                    e.printStackTrace();
                    httpResponse.code = 1000;
                    mUiHandler.sendMessage(mUiHandler.obtainMessage(1, task));
                }
            }
            break;
        default:
            break;
    }
}

private Observable<List> observableNetwork(final WimcRequest request) {
    return getResponse(request).flatMap(new Func1<Response, Observable<String>>() {

        @Override
        public Observable<String> call(Response response) {
            return responseToString(response);
        }
    }).flatMap(new Func1<String, Observable<List>>() {

        @Override
        public Observable<List> call(String s) {
            return request.observableStringToObjectsList(s);
        }
    });
}

/**
     * Uploads an image to Google Cloud Storage.
     * @param url the upload url.
     * @param bitmap the image to upload.
     * @throws IOException if cannot upload the image.
     */
public static void uploadImage(String url, Bitmap bitmap) throws IOException {
    ByteArrayOutputStream bOS = new ByteArrayOutputStream();
    bitmap.compress(Bitmap.CompressFormat.JPEG, 100, bOS);
    byte[] bitmapData = bOS.toByteArray();
    InputStream stream = new ByteArrayInputStream(bitmapData);
    String contentType = URLConnection.guessContentTypeFromStream(stream);
    InputStreamContent content = new InputStreamContent(contentType, stream);
    MediaType MEDIA_TYPE_JPEG = MediaType.parse("image/jpeg");
    OkHttpClient client = new OkHttpClient();
    RequestBody requestBody = RequestBodyUtil.create(MEDIA_TYPE_JPEG, content.getInputStream());
    Request request = new Request.Builder().url(url).put(requestBody).build();
    Response response = client.newCall(request).execute();
    if (!response.isSuccessful()) {
        throw new IOException("Unexpected code " + response);
    }
}

/**
     * Called when the HTTP response was successfully returned by the remote server
     *
     * @param response
     */
@Override
public void onResponse(final Response response) {
    mActivity.runOnUiThread(new Runnable() {

        @Override
        public void run() {
            onComplete(response.request(), true);
        }
    });
    try {
        final ResponseJson json = JSONObject.parseObject(response.body().bytes(), ResponseJson.class);
        mActivity.runOnUiThread(new Runnable() {

            @Override
            public void run() {
                if (json.statusSuccess()) {
                    try {
                        onApiSuccess(response, json);
                    } catch (Exception e) {
                        onApiFailure(response, json, e);
                    }
                } else if (json.statusAuthFailure()) {
                    onApiAuthFailure(response, json);
                } else {
                    onApiFailure(response, json, null);
                }
            }
        });
    } catch (final Exception e) {
        mActivity.runOnUiThread(new Runnable() {

            @Override
            public void run() {
                onApiFailure(response, null, e);
            }
        });
    }
}

@Override
public Response intercept(Chain chain) throws IOException {
    com.squareup.okhttp.Request request = chain.request();
    String url = request.urlString();
    String authentication = DBReader.getImageAuthentication(url);
    if (TextUtils.isEmpty(authentication)) {
        Log.d(TAG, "no credentials for '" + url + "'");
        return chain.proceed(request);
    }
    // add authentication
    String[] auth = authentication.split(":");
    String credentials = HttpDownloader.encodeCredentials(auth[0], auth[1], "ISO-8859-1");
    com.squareup.okhttp.Request newRequest = request.newBuilder().addHeader("Authorization", credentials).build();
    Log.d(TAG, "Basic authentication with ISO-8859-1 encoding");
    Response response = chain.proceed(newRequest);
    if (!response.isSuccessful() && response.code() == HttpURLConnection.HTTP_UNAUTHORIZED) {
        credentials = HttpDownloader.encodeCredentials(auth[0], auth[1], "UTF-8");
        newRequest = request.newBuilder().addHeader("Authorization", credentials).build();
        Log.d(TAG, "Basic authentication with UTF-8 encoding");
        return chain.proceed(newRequest);
    } else {
        return response;
    }
}

/**
     * @param OrderId
     * @param TradeChannel
     * @param TradeType
     * @param TransactionId
     * @function 更新系统内的订�状�
     */
//
@SneakyThrows
public Map<String, Object> updateOrderState(String OrderId, String TradeChannel, String TradeType, String TransactionId) {
    String url = "http://121.40.48.71:8092/api/UpdateOrderState?OrderId=" + OrderId + "&TradeChannel=1&TradeType=1&TransactionId=" + TransactionId;
    //构建请求
    Request request = new Request.Builder().url(url).get().build();
    Map<String, Object> result = new HashMap<>();
    //�起请求
    Response response = new OkHttpClient().newCall(request).execute();
    //解�获�的数�并且返回Map
    JSONObject.parseObject(response.body().string()).forEach(( k,  v) -> {
        result.put(k, String.valueOf(v));
    });
    return result;
}

public String performPreauth(String failmode) throws Exception {
    if (failmode.equals("secure")) {
        return "auth";
    } else if (!failmode.equals("safe")) {
        throw new IllegalArgumentException("Failmode must be one of either safe or secure.");
    }
    // Check if Duo authentication is even necessary by calling preauth
    for (int i = 0; ; i++) {
        try {
            Response preAuthResponse = sendPreAuthRequest(username);
            int statusCode = preAuthResponse.code();
            if (statusCode / 100 == 5) {
                log.warn("Duo 500 error. Fail open for user:" + username);
                return "allow";
            }
            // parse response
            JSONObject json = new JSONObject(preAuthResponse.body().string());
            if (!json.getString("stat").equals("OK")) {
                throw new Exception("Duo error code (" + json.getInt("code") + "): " + json.getString("message"));
            }
            String result = json.getJSONObject("response").getString("result");
            if (result.equals("allow")) {
                log.info("Duo 2FA bypass for user:" + username);
                return "allow";
            }
            break;
        } catch (java.io.IOException e) {
            if (i >= MAX_TRIES - 1) {
                log.warn("Duo server unreachable. Fail open for user:" + username);
                return "allow";
            }
        }
    }
    return "auth";
}

public List<Show> searchShows(String query) {
    try {
        final String escapedQuery = URLEncoder.encode(query, "UTF-8");
        final String url = String.format("%s/GetSeries.php?seriesname=%s&language=all", baseUrl, escapedQuery);
        Log.d(TAG, String.format("Sending request to %s", url));
        final Request request = new Request.Builder().url(url).build();
        final Response response = http.newCall(request).execute();
        Log.d(TAG, String.format("Received response %d: %s", response.code(), response.message()));
        if (response.isSuccessful()) {
            final SearchShowsParser parser = new SearchShowsParser();
            return parser.parse(response.body().byteStream());
        } else {
            return null;
        }
    } catch (IOException e) {
        Log.w(TAG, e);
        return null;
    }
}

@Override
public void onResponse(Response response) {
    final ResponseBody body = response.body();
    try {
        long contentLength = body.contentLength();
        if (contentLength < 0) {
            contentLength = 0;
        }
        callback.onResponse(body.byteStream(), (int) contentLength);
    } catch (IOException ioe) {
        handleException(call, ioe, callback);
    } finally {
        try {
            body.close();
        } catch (IOException ioe) {
            FLog.w(TAG, "Exception when closing response body", ioe);
        }
    }
}

@Override
public void onClick(View v) {
    switch(v.getId()) {
        case R.id.top_bar_linear_back:
            OkhttpDemoActivity.this.finish();
            break;
        case //�步get
        R.id.btn_one:
            request = new Request.Builder().url("http://interface.zttmall.com/update/mallUpdate").build();
            new Thread(new Runnable() {

                @Override
                public void run() {
                    try {
                        response = client.newCall(request).execute();
                        Headers responseHeaders = response.headers();
                        for (int i = 0; i < responseHeaders.size(); i++) {
                            Log.d("zttjiangqq", responseHeaders.name(i) + ": " + responseHeaders.value(i));
                        }
                        final String message = response.body().string();
                        runOnUiThread(new Runnable() {

                            @Override
                            public void run() {
                                tv_result.setText(message);
                            }
                        });
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }).start();
            break;
        case //异步Get
        R.id.btn_two:
            request = new Request.Builder().url("http://www.baidu.com").build();
            client.newCall(request).enqueue(new Callback() {

                @Override
                public void onFailure(Request request, IOException e) {
                }

                @Override
                public void onResponse(Response response) throws IOException {
                    final String message = response.body().string();
                    runOnUiThread(new Runnable() {

                        @Override
                        public void run() {
                            tv_result.setText(message);
                        }
                    });
                }
            });
            break;
    }
}

/* package */
static Observable<File> downloadFile(final String url, final String path) {
    return Observable.create( subscriber -> {
        final Request request = new Request.Builder().url(url).build();
        try {
            if (!subscriber.isUnsubscribed()) {
                final File file = new File(path);
                if (!file.exists()) {
                    file.getParentFile().mkdirs();
                    Timber.i("downloadFile: Downloading " + file.getName());
                    final Response response = sClient.newCall(request).execute();
                    final BufferedSink sink = Okio.buffer(Okio.sink(file));
                    sink.writeAll(response.body().source());
                    sink.close();
                } else
                    Timber.i("downloadFile: Retrieved from cache " + file.getName());
                subscriber.onNext(file);
                subscriber.onCompleted();
            }
        } catch (IOException e) {
            subscriber.onError(new DownloadException(e));
        }
    });
}

/**
     * @param request A request that isn't expected to return a response body,
     *                or where the response body should be ignored.
     */
public static void send(@NonNull final Request request) {
    try {
        final Response response = OkHttpClientFactory.getClient().newCall(request).execute();
        if (response.code() != HttpURLConnection.HTTP_OK && response.code() != HttpURLConnection.HTTP_NO_CONTENT && response.code() != HttpURLConnection.HTTP_CREATED) {
            Reader in = null;
            try {
                in = response.body().charStream();
                // If the response input stream is null, assume no connection.
                if (in == null) {
                    throw new GameUpException(0, "No Connection");
                }
                try {
                    throw GsonFactory.get().fromJson(in, GameUpException.class);
                } catch (final JsonParseException e) {
                    throw new GameUpException(500, "Unknown error data", null);
                }
            } finally {
                Utils.closeQuietly(in);
            }
        }
    } catch (final IOException e) {
        throw new GameUpException(400, "Failed to execute request", null);
    }
}

@Override
public void onResponse(Response response) {
    final ResponseBody body = response.body();
    try {
        long contentLength = body.contentLength();
        if (contentLength < 0) {
            contentLength = 0;
        }
        processResult(requestState, body.byteStream(), (int) contentLength, false);
    } catch (IOException ioe) {
        handleException(call, requestState, ioe);
    } finally {
        try {
            body.close();
        } catch (IOException ioe) {
            FLog.w(TAG, "Exception when closing response body", ioe);
        }
    }
}

@Override
public Response intercept(Chain chain) throws IOException {
    String url = chain.request().urlString();
    // Get the current server from secure storage
    String server = Hawk.get(Preferences.KEY_SERVER);
    // Add the basic auth header only in Jira server requests
    if (url.contains(server)) {
        Request.Builder builder = chain.request().newBuilder();
        Header header = BasicAuth.getBasicAuthHeader();
        if (header != null) {
            builder.addHeader(header.getName(), header.getValue());
        }
        return chain.proceed(builder.build());
    } else // Skip image requests that are not for the current Jira server
    {
        return chain.proceed(chain.request());
    }
}

public WebResponse toWebViewResponse(Response response) {
    final String mimeType = response.header(CONTENT_TYPE);
    final String encoding = response.header(CONTENT_ENCODING);
    final InputStream data = extractData(response);
    final int statusCode = response.code();
    final String reasonPhrase = response.message();
    final Map<String, String> responseHeaders = extractHeaders(response);
    return new WebResponse() {

        @Override
        public String getMimeType() {
            return mimeType;
        }

        @Override
        public String getEncoding() {
            return encoding;
        }

        @Override
        public InputStream getData() {
            return data;
        }

        @Override
        public int getStatusCode() {
            return statusCode;
        }

        @Override
        public String getReasonPhrase() {
            return reasonPhrase;
        }

        @Override
        public Map<String, String> getResponseHeaders() {
            return responseHeaders;
        }
    };
}

/**
   * Downloads and returns a URL as a {@link Bitmap}.
   *
   * @param url the image to download
   * @return a new {@link Bitmap}, or {@code null} if any error occurred
   */
public static Bitmap downloadBitmap(String url) {
    final OkHttpClient client = new OkHttpClient();
    final Request request = new Request.Builder().url(url).build();
    Response response = null;
    Bitmap bitmap = null;
    try {
        response = client.newCall(request).execute();
    } catch (IOException e) {
        return null;
    }
    if (response.isSuccessful()) {
        BitmapFactory.Options options = new BitmapFactory.Options();
        options.inSampleSize = 2;
        try {
            bitmap = BitmapFactory.decodeStream(response.body().byteStream(), null, options);
        } catch (Exception e) {
            return null;
        }
    }
    return bitmap;
}

@Override
public void onResponse(final Response response) throws IOException {
    final String rawData = response.body().string();
    Handler handler = new Handler(Looper.getMainLooper());
    handler.post(new Runnable() {

        @Override
        public void run() {
            ScienceContentParser myParse = new ScienceContentParser(rawData);
            String data = myParse.getEndStr();
            scrollView.setVisibility(View.VISIBLE);
            scrollView.setOnScrollChangeListener(new NestedScrollView.OnScrollChangeListener() {

                @Override
                public void onScrollChange(NestedScrollView v, int scrollX, int scrollY, int oldScrollX, int oldScrollY) {
                    topImage.setTranslationY(Math.max(-scrollY / 2, -DisplayUtil.dip2px(getBaseContext(), 170)));
                }
            });
            contentView.loadDataWithBaseURL("file:///android_asset/", "<link rel=\"stylesheet\" type=\"text/css\" href=\"guokr.css\" />" + data, "text/html", "utf-8", null);
        }
    });
}

@Override
public void run() {
    int attempt = 0;
    while ((webSocket = newSocket()) != null) {
        try {
            Response response = webSocket.connect(OkHttpClientWrapper.this);
            if (response.code() == 101) {
                synchronized (OkHttpClientWrapper.this) {
                    if (closed)
                        webSocket.close(1000, "OK");
                    else
                        connected = true;
                }
                listener.onConnected();
                return;
            }
            Log.w(TAG, "WebSocket Response: " + response.code());
        } catch (IOException e) {
            Log.w(TAG, e);
        }
        Util.sleep(Math.min(++attempt * 200, TimeUnit.SECONDS.toMillis(15)));
    }
}

@Override
public Response intercept(Chain chain) throws IOException {
    Request.Builder builder = chain.request().newBuilder();
    // add token
    String token = PreferenceManager.getDefaultSharedPreferences(context).getString(context.getString(R.string.tokenKey), null);
    if (token != null && !token.trim().isEmpty()) {
        builder.addHeader("Authorization", "Bearer " + token);
    }
    // add Accept-Encoding:gzip
    builder.addHeader("Accept-Encoding", "gzip").addHeader("User-Agent", userAgent);
    Response response = chain.proceed(builder.build());
    int statusCode = response.code();
    if (statusCode == HTTP_UNAUTHORIZED) {
        UserUtility userUtility = UserUtility.getInstance(context);
        // If token has not expired yet, expire it and send notification to listeners
        if (!userUtility.isTokenExpired()) {
            UserUtility.getInstance(context).clearTokenInformation();
            for (IUserEventListener listener : listeners) {
                listener.onTokenExpired();
            }
        }
        Log.w(LOG_NAME, "TOKEN EXPIRED");
    } else if (statusCode == HTTP_NOT_FOUND) {
        Log.w(LOG_NAME, "404 Not Found.");
    }
    return response;
}

@Override
public void onCreate() {
    super.onCreate();
    //noinspection ConstantConditions
    if (TextUtils.isEmpty(BuildConfig.CLIENT_ID) || TextUtils.isEmpty(BuildConfig.CLIENT_SECRET)) {
        throw new IllegalStateException("Please create a \"client.properties\" in the same" + " directory of this module to specify your CLIENT_ID and CLIENT_SECRET.");
    }
    InstaSharedState.createInstance(this);
    httpClient = new OkHttpClient();
    httpClient.interceptors().add( chain -> {
        Request request = chain.request();
        Log.d("OkHttp", request.toString());
        Response response = chain.proceed(request);
        Log.d("OkHttp", response.toString());
        return response;
    });
    InstaSharedState.getInstance().applyProxy();
    Gson gson = new GsonBuilder().setFieldNamingPolicy(FieldNamingPolicy.LOWER_CASE_WITH_UNDERSCORES).registerTypeAdapter(Date.class, new TimestampTypeAdapter()).create();
    retrofit = new Retrofit.Builder().client(httpClient).addConverterFactory(GsonConverterFactory.create(gson)).addCallAdapterFactory(RxJavaCallAdapterFactory.create()).baseUrl("https://api.instagram.com/").build();
}

@Override
public void after(Object target, Object[] args, Object result, Throwable throwable) {
    if (isDebug) {
        logger.afterInterceptor(target, args);
    }
    final Trace trace = traceContext.currentTraceObject();
    if (trace == null) {
        return;
    }
    if (!validate(target)) {
        return;
    }
    try {
        SpanEventRecorder recorder = trace.currentSpanEventRecorder();
        recorder.recordApi(methodDescriptor);
        recorder.recordException(throwable);
        if (statusCode) {
            // type check validate();
            Response response = ((UserResponseGetter) target)._$PINPOINT$_getUserResponse();
            if (response != null) {
                recorder.recordAttribute(AnnotationKey.HTTP_STATUS_CODE, response.code());
            }
        }
    } finally {
        trace.traceBlockEnd();
    }
}

public String reverseGeocoding(double lat, double lng) {
    String url = String.format(URL, lat, lng);
    Request request = new Request.Builder().url(url).build();
    try {
        Response response = client.newCall(request).execute();
        String responseBody = response.body().string();
        JSONObject reader = new JSONObject(responseBody);
        return reader.optString("display_name");
    } catch (IOExceptionJSONException |  e) {
        Timber.e(e, "Failed to parse response");
    }
    return "";
}

public static Observable<Point> getLocationForAddress(String address) {
    return ReactiveUtils.subscribeIoObserveImmediate( subscriber -> {
        String url = String.format(GOOGLE_GEOCODE_SVC_TEMPLATE_URL, URLEncoder.encode(address));
        OkHttpClient client = PFNetworkManager.getStandardHttpClient();
        Request geocodeRequest = new Request.Builder().url(url).build();
        try {
            Response geocodeResponse = client.newCall(geocodeRequest).execute();
            GeocodeResponse response = gson.fromJson(geocodeResponse.body().charStream(), GeocodeResponse.class);
            if (!response.getResults().isEmpty()) {
                GoogleGeocode.Location location = response.getResults().get(0).getGeometry().getLocation();
                Point p = new Point(location.getLat(), location.getLng());
                subscriber.onNext(p);
            }
            subscriber.onCompleted();
        } catch (IOException e) {
            Timber.e(e, "Couldn't geocode zip.");
            subscriber.onError(e);
        }
    });
}

@Override
public void after(Object target, Object[] args, Object result, Throwable throwable) {
    if (isDebug) {
        logger.afterInterceptor(target, args);
    }
    final Trace trace = traceContext.currentTraceObject();
    if (trace == null) {
        return;
    }
    if (!validate(target)) {
        return;
    }
    try {
        SpanEventRecorder recorder = trace.currentSpanEventRecorder();
        recorder.recordApi(methodDescriptor);
        recorder.recordException(throwable);
        if (statusCode) {
            // type check validate();
            Response response = ((UserResponseGetter) target)._$PINPOINT$_getUserResponse();
            if (response != null) {
                recorder.recordAttribute(AnnotationKey.HTTP_STATUS_CODE, response.code());
            }
        }
    } finally {
        trace.traceBlockEnd();
    }
}

@Override
public void send(Notification notification) {
    StringBuilder builder = new StringBuilder(url).append("?token=").append(configuration.token()).append("&channel=").append(encode(configuration.channel())).append("&attachments=").append(encode(attachments(notification)));
    try {
        String requestUrl = builder.toString();
        LOGGER.debug("Calling Slack with parameters: {}", requestUrl);
        Response response = client.newCall(new Request.Builder().url(requestUrl).get().build()).execute();
        if (response.code() != 200) {
            String message = String.format("Slack notification has failed, [%s] - [%s]%n%s", response.code(), response.message(), response.body().string());
            LOGGER.error(message);
            throw new SlackNotificationException(message);
        }
    } catch (IOException e) {
        String message = "Error while sending Slack notification.";
        LOGGER.error(message, e);
        throw new SlackNotificationException(message, e);
    }
}

public static void sendLocationsForm(Context context) throws Exception {
    ServerEntity serverEntity = AppSettings.getServerEntity(context);
    for (; ; ) {
        List<LocationModel> locationEntities = LocationDAO.queryNextLocations(context, 100);
        if (locationEntities != null && locationEntities.size() > 0) {
            String requestJsonString = AppConstants.GSON.toJson(locationEntities);
            OkHttpClient client = new OkHttpClient();
            Request request = new Request.Builder().url(serverEntity.server_address).build();
            if (DEBUG) {
                Log.d(TAG, "Send request: " + request.urlString() + " " + requestJsonString);
            }
            Response response = client.newCall(request).execute();
            String responseJsonString = response.body().string();
            if (DEBUG) {
                Log.d(TAG, "Received response: " + responseJsonString);
            }
            SendLocationsResponseDTO statusResponse = AppConstants.GSON.fromJson(responseJsonString, SendLocationsResponseDTO.class);
            if (statusResponse != null && statusResponse.success) {
                LocationDAO.deleteLocations(context, locationEntities);
                incPacketCounter(context, locationEntities.size());
                Log.d(context.getPackageName(), "Packet is send: " + locationEntities.size() + " " + responseJsonString);
            } else {
                Log.e(context.getPackageName(), "Packet is not send: " + responseJsonString);
                break;
            }
        } else {
            break;
        }
    }
}

@Override
protected ClientHttpResponse executeInternal(HttpHeaders headers, byte[] content) throws IOException {
    boolean requiresBody = method == HttpMethod.POST || method == HttpMethod.PUT || method == HttpMethod.PATCH;
    RequestBody body;
    if (requiresBody && content.length == 0) {
        body = RequestBody.create(null, NO_BODY);
    } else {
        MediaType contentType = getContentType(headers);
        body = (content.length > 0 ? RequestBody.create(contentType, content) : null);
    }
    URL url = this.uri.toURL();
    String methodName = this.method.name();
    Request.Builder builder = new Request.Builder().url(url).method(methodName, body);
    for (Map.Entry<String, List<String>> entry : headers.entrySet()) {
        String headerName = entry.getKey();
        for (String headerValue : entry.getValue()) {
            builder.addHeader(headerName, headerValue);
        }
    }
    Request request = builder.build();
    Response response = null;
    try {
        response = client.newCall(request).execute();
    } catch (ProtocolException e) {
        if (PROXY_AUTH_ERROR.equals(e.getMessage())) {
            throw new HttpClientErrorException(HttpStatus.PROXY_AUTHENTICATION_REQUIRED, HttpStatus.PROXY_AUTHENTICATION_REQUIRED.getReasonPhrase());
        } else {
            throw e;
        }
    }
    return new OkHttpClientHttpResponse(response);
}