/**
  * 构造GET请求对象
  *
  * @param url
  * @param params
  * @return
  */
 private Request buildGetRequest(String url, Map<String, Object> params) {
   HttpUrl fullUrl = buildUrl(url, params);
   Request.Builder builder = new Request.Builder().url(fullUrl);
   wrapHttpHeader(builder, url);
   builder.tag(url);
   return builder.build();
 }
Example #2
0
  public Response send(final Request.Builder requestBuilder, StringMap headers)
      throws QiniuException {
    if (headers != null) {
      headers.forEach(
          new StringMap.Consumer() {
            @Override
            public void accept(String key, Object value) {
              requestBuilder.header(key, value.toString());
            }
          });
    }

    requestBuilder.header("User-Agent", userAgent());
    long start = System.currentTimeMillis();
    com.squareup.okhttp.Response res = null;
    Response r;
    double duration = (System.currentTimeMillis() - start) / 1000.0;
    IpTag tag = new IpTag();
    try {
      res = httpClient.newCall(requestBuilder.tag(tag).build()).execute();
    } catch (IOException e) {
      e.printStackTrace();
      throw new QiniuException(e);
    }
    r = Response.create(res, tag.ip, duration);
    if (r.statusCode >= 300) {
      throw new QiniuException(r);
    }

    return r;
  }
  /**
   * Fetch the list of movies from YTS
   *
   * @param currentList Current shown list to be extended
   * @param requestBuilder Request to be executed
   * @param callback Network callback
   * @return Call
   */
  private Call fetchList(
      final ArrayList<Media> currentList,
      final Request.Builder requestBuilder,
      final Filters filters,
      final Callback callback) {
    requestBuilder.addHeader("Host", "xor.image.yt");
    return enqueue(
        requestBuilder.build(),
        new com.squareup.okhttp.Callback() {
          @Override
          public void onFailure(Request request, IOException e) {
            if (generateFallback(requestBuilder)) {
              fetchList(currentList, requestBuilder, filters, callback);
            } else {
              callback.onFailure(e);
            }
          }

          @Override
          public void onResponse(Response response) throws IOException {
            if (response.isSuccessful()) {
              String responseStr;
              try {
                responseStr = response.body().string();
              } catch (SocketException e) {
                onFailure(response.request(), new IOException("Socket failed"));
                return;
              }

              YTSReponse result;
              try {
                result = mGson.fromJson(responseStr, YTSReponse.class);
              } catch (IllegalStateException e) {
                onFailure(response.request(), new IOException("JSON Failed"));
                return;
              } catch (JsonSyntaxException e) {
                onFailure(response.request(), new IOException("JSON Failed"));
                return;
              }

              if (result.status != null && result.status.equals("error")) {
                callback.onFailure(new NetworkErrorException(result.status_message));
              } else if (result.data != null
                  && ((result.data.get("movies") != null
                          && ((ArrayList<LinkedTreeMap<String, Object>>) result.data.get("movies"))
                                  .size()
                              <= 0)
                      || ((Double) result.data.get("movie_count")).intValue()
                          <= currentList.size())) {
                callback.onFailure(new NetworkErrorException("No movies found"));
              } else {
                ArrayList<Media> formattedData = result.formatForPopcorn(currentList);
                callback.onSuccess(filters, formattedData, true);
                return;
              }
            }
            onFailure(response.request(), new IOException("Couldn't connect to YTS"));
          }
        });
  }
  private HttpEngine newHttpEngine(
      String method, Connection connection, RetryableOutputStream requestBody) throws IOException {
    Request.Builder builder =
        new Request.Builder()
            .url(getURL())
            .method(method, null /* No body; that's passed separately. */);
    Headers headers = requestHeaders.build();
    for (int i = 0; i < headers.size(); i++) {
      builder.addHeader(headers.name(i), headers.value(i));
    }

    boolean bufferRequestBody;
    if (fixedContentLength != -1) {
      bufferRequestBody = false;
      builder.header("Content-Length", Long.toString(fixedContentLength));
    } else if (chunkLength > 0) {
      bufferRequestBody = false;
      builder.header("Transfer-Encoding", "chunked");
    } else {
      bufferRequestBody = true;
    }

    Request request = builder.build();

    // If we're currently not using caches, make sure the engine's client doesn't have one.
    OkHttpClient engineClient = client;
    if (engineClient.getOkResponseCache() != null && !getUseCaches()) {
      engineClient = client.clone().setOkResponseCache(null);
    }

    return new HttpEngine(engineClient, request, bufferRequestBody, connection, requestBody);
  }
  @Override
  public Call getDetail(String videoId, Callback callback) {
    Request.Builder requestBuilder = new Request.Builder();
    requestBuilder.url(API_URL + "movie_details.json?movie_id=" + videoId);
    requestBuilder.addHeader("Host", "xor.image.yt");
    requestBuilder.tag(MEDIA_CALL);

    return fetchDetail(requestBuilder, callback);
  }
  @Override
  public Request buildRequest() {
    Request.Builder builder = new Request.Builder();
    String url =
        getUrl() + "?key=" + cacHttpClient.getApiKey() + "&login=" + cacHttpClient.getLogin();
    builder.url(url);

    return builder.build();
  }
 /**
  * 设置Http Header
  *
  * @param builder
  */
 private void wrapHttpHeader(Request.Builder builder, String url) {
   for (Map.Entry<String, String> item : this.headers) {
     builder.addHeader(item.getKey(), item.getValue());
   }
   final String signRequest = appSession.signRequest(url);
   builder.addHeader(HEADER_X_SIGN, signRequest);
   builder.addHeader(HEADER_ACCEPT, APPLICATION_X_PROTOBUF);
   builder.addHeader(HEADER_USER_AGENT, this.userAgent);
   // Timber.e("signRequest: %s %s", url, signRequest);
 }
 /**
  * Set header parameters to the request builder, including default headers.
  *
  * @param headerParams Header parameters in the ofrm of Map
  * @param reqBuilder Reqeust.Builder
  */
 public void processHeaderParams(Map<String, String> headerParams, Request.Builder reqBuilder) {
   for (Entry<String, String> param : headerParams.entrySet()) {
     reqBuilder.header(param.getKey(), parameterToString(param.getValue()));
   }
   for (Entry<String, String> header : defaultHeaderMap.entrySet()) {
     if (!headerParams.containsKey(header.getKey())) {
       reqBuilder.header(header.getKey(), parameterToString(header.getValue()));
     }
   }
 }
 @Override
 protected Request buildRequest() {
   if (TextUtils.isEmpty(url)) {
     throw new IllegalArgumentException("url can not be empty!");
   }
   Request.Builder builder = new Request.Builder();
   appendHeaders(builder, headers);
   builder.url(url).tag(tag).post(requestBody);
   return builder.build();
 }
  /**
   * Build HTTP call with the given options.
   *
   * @param path The sub-path of the HTTP URL
   * @param method The request method, one of "GET", "HEAD", "OPTIONS", "POST", "PUT", "PATCH" and
   *     "DELETE"
   * @param queryParams The query parameters
   * @param body The request body object
   * @param headerParams The header parameters
   * @param formParams The form parameters
   * @param authNames The authentications to apply
   * @param progressRequestListener Progress request listener
   * @return The HTTP call
   * @throws ApiException If fail to serialize the request body object
   */
  public Call buildCall(
      String path,
      String method,
      List<Pair> queryParams,
      Object body,
      Map<String, String> headerParams,
      Map<String, Object> formParams,
      String[] authNames,
      ProgressRequestBody.ProgressRequestListener progressRequestListener)
      throws ApiException {
    updateParamsForAuth(authNames, queryParams, headerParams);

    final String url = buildUrl(path, queryParams);
    final Request.Builder reqBuilder = new Request.Builder().url(url);
    processHeaderParams(headerParams, reqBuilder);

    String contentType = (String) headerParams.get("Content-Type");
    // ensuring a default content type
    if (contentType == null) {
      contentType = "application/json";
    }

    RequestBody reqBody;
    if (!HttpMethod.permitsRequestBody(method)) {
      reqBody = null;
    } else if ("application/x-www-form-urlencoded".equals(contentType)) {
      reqBody = buildRequestBodyFormEncoding(formParams);
    } else if ("multipart/form-data".equals(contentType)) {
      reqBody = buildRequestBodyMultipart(formParams);
    } else if (body == null) {
      if ("DELETE".equals(method)) {
        // allow calling DELETE without sending a request body
        reqBody = null;
      } else {
        // use an empty request body (for POST, PUT and PATCH)
        reqBody = RequestBody.create(MediaType.parse(contentType), "");
      }
    } else {
      reqBody = serialize(body, contentType);
    }

    Request request = null;

    if (progressRequestListener != null && reqBody != null) {
      ProgressRequestBody progressRequestBody =
          new ProgressRequestBody(reqBody, progressRequestListener);
      request = reqBuilder.method(method, progressRequestBody).build();
    } else {
      request = reqBuilder.method(method, reqBody).build();
    }

    return httpClient.newCall(request);
  }
Example #11
0
 @Override
 protected Request buildRequest() {
   if (TextUtils.isEmpty(url)) {
     throw new IllegalArgumentException("url can not be empty!");
   }
   // append params , if necessary
   url = appendParams(url, params);
   Request.Builder builder = new Request.Builder();
   // add headers , if necessary
   appendHeaders(builder, headers);
   builder.url(url).tag(tag);
   return builder.build();
 }
 private boolean generateFallback(Request.Builder requestBuilder) {
   String url = requestBuilder.build().urlString();
   if (url.contains(MIRROR_URL2)) {
     return false;
   } else if (url.contains(MIRROR_URL)) {
     url = url.replace(MIRROR_URL, MIRROR_URL2);
     CURRENT_URL = MIRROR_URL2;
   } else {
     url = url.replace(API_URL, MIRROR_URL);
     CURRENT_URL = MIRROR_URL;
   }
   requestBuilder.url(url);
   return true;
 }
  @Override
  public HttpResponse performRequest(Request<?> request, Map<String, String> additionalHeaders)
      throws IOException, AuthFailureError {
    OkHttpClient client = okHttpClient.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);
    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;
  }
Example #14
0
  private APIResponse get_single(final String urlString, int expectedReturnCode) {
    if (!NetworkUtils.isOnline(context)) {
      return new APIResponse(context);
    }

    if (AppConstants.VERBOSE_LOG) {
      Log.d(this.getClass().getName(), "API GET " + urlString);
    }

    Request.Builder requestBuilder = new Request.Builder().url(urlString);
    addCookieHeader(requestBuilder);
    requestBuilder.header("User-Agent", this.customUserAgent);

    return new APIResponse(context, httpClient, requestBuilder.build(), expectedReturnCode);
  }
 @Override
 public Response intercept(Chain chain) throws IOException {
   Request originalRequest = chain.request();
   Request.Builder request = originalRequest.newBuilder();
   if (originalRequest.header("fresh") != null) {
     request.cacheControl(CacheControl.FORCE_NETWORK);
   }
   Response response = chain.proceed(request.build());
   return response
       .newBuilder()
       .removeHeader("Pragma")
       .removeHeader("Cache-Control")
       .header("Cache-Control", cacheControl())
       .build();
 }
    @Override
    protected String doInBackground(Void... params) {
      try {
        OkHttpClient okHttpClient = new OkHttpClient();
        Request.Builder builder = new Request.Builder();
        Request request = builder.url(myURL).build();
        Response response = okHttpClient.newCall(request).execute();
        return response.body().string();

      } catch (Exception e) {

        Log.d("Spinner", "e doInBack ==> " + e.toString());
        return null;
      }
    }
  private void call(
      Request request,
      final Net.Parser<T> parser,
      final Net.Callback<T> callback,
      final Object tag) {
    Request.Builder builder = request.newBuilder();
    if (tag != null) builder.tag(tag);
    // 在这里添加头部文件
    LinkedHashMap<String, String> map = headers();
    if (map != null && !map.isEmpty()) {
      for (Iterator<String> iterator = map.keySet().iterator(); iterator.hasNext(); ) {
        String key = iterator.next();
        builder.addHeader(key, map.get(key));
      }
      request = builder.build();
    }

    OkHttpClient client = mClient.clone();
    client.setConnectTimeout(20, TimeUnit.SECONDS);

    final Call call = client.newCall(request);
    call.enqueue(
        new Callback() {
          @Override
          public void onFailure(Request request, final IOException e) {
            final String msg = e.getMessage();
            mHandler.post(
                new Runnable() {
                  @Override
                  public void run() {
                    onError(callback, msg);
                  }
                });
          }

          @Override
          public void onResponse(final Response response) throws IOException {
            final String resp = response.body().string();
            mHandler.post(
                new Runnable() {
                  @Override
                  public void run() {
                    onNetResponse(parser, callback, resp);
                  }
                });
          }
        });
  }
Example #18
0
 private void addCookieHeader(Request.Builder requestBuilder) {
   SharedPreferences preferences = context.getSharedPreferences(PrefConstants.PREFERENCES, 0);
   String cookie = preferences.getString(PrefConstants.PREF_COOKIE, null);
   if (cookie != null) {
     requestBuilder.header("Cookie", cookie);
   }
 }
Example #19
0
  public void connect() throws IOException {
    LOG.log(Level.FINE, "connect");
    disconnect();
    // No support for ws:// or ws:// in okhttp. See https://github.com/square/okhttp/issues/1652
    final String httpUrl =
        this.endpointUri.replaceFirst("^ws:", "http:").replaceFirst("^wss:", "https:");

    Request.Builder builder = new Request.Builder().url(httpUrl);
    if (socketConnectionRequestHeaders != null)
      for (Map.Entry<String, String> entry : socketConnectionRequestHeaders.entrySet())
        builder.addHeader(entry.getKey(), entry.getValue());
    final Request request = builder.build();

    final WebSocketCall wsCall = WebSocketCall.create(httpClient, request);
    wsCall.enqueue(wsListener);
  }
Example #20
0
  private APIResponse post_single(String urlString, RequestBody formBody) {
    if (!NetworkUtils.isOnline(context)) {
      return new APIResponse(context);
    }

    if (AppConstants.VERBOSE_LOG) {
      Log.d(this.getClass().getName(), "API POST " + urlString);
      Log.d(this.getClass().getName(), "post body: " + formBody.toString());
    }

    Request.Builder requestBuilder = new Request.Builder().url(urlString);
    addCookieHeader(requestBuilder);
    requestBuilder.post(formBody);

    return new APIResponse(context, httpClient, requestBuilder.build());
  }
  @SuppressWarnings("deprecation")
  private static void setConnectionParametersForRequest(
      com.squareup.okhttp.Request.Builder builder, Request<?> request)
      throws IOException, AuthFailureError {
    switch (request.getMethod()) {
      case Request.Method.DEPRECATED_GET_OR_POST:
        // Ensure backwards compatibility.
        // Volley assumes a request with a null body is a GET.
        byte[] postBody = request.getPostBody();

        if (postBody != null) {
          builder.post(
              RequestBody.create(MediaType.parse(request.getPostBodyContentType()), postBody));
        }
        break;

      case Request.Method.GET:
        builder.get();
        break;

      case Request.Method.DELETE:
        builder.delete();
        break;

      case Request.Method.POST:
        builder.post(createRequestBody(request));
        break;

      case Request.Method.PUT:
        builder.put(createRequestBody(request));
        break;

      case Request.Method.HEAD:
        builder.head();
        break;

      case Request.Method.OPTIONS:
        builder.method("OPTIONS", null);
        break;

      case Request.Method.TRACE:
        builder.method("TRACE", null);
        break;

      case Request.Method.PATCH:
        builder.patch(createRequestBody(request));
        break;

      default:
        throw new IllegalStateException("Unknown method type.");
    }
  }
Example #22
0
 private Request networkRequest(Request request)
 {
     com.squareup.okhttp.Request.Builder builder = request.newBuilder();
     if (request.header("Host") == null)
     {
         builder.header("Host", Util.hostHeader(request.httpUrl()));
     }
     if ((connection == null || connection.getProtocol() != Protocol.HTTP_1_0) && request.header("Connection") == null)
     {
         builder.header("Connection", "Keep-Alive");
     }
     if (request.header("Accept-Encoding") == null)
     {
         transparentGzip = true;
         builder.header("Accept-Encoding", "gzip");
     }
     CookieHandler cookiehandler = client.getCookieHandler();
     if (cookiehandler != null)
     {
         java.util.Map map = OkHeaders.toMultimap(builder.build().headers(), null);
         OkHeaders.addCookies(builder, cookiehandler.get(request.uri(), map));
     }
     if (request.header("User-Agent") == null)
     {
         builder.header("User-Agent", Version.userAgent());
     }
     return builder.build();
 }
Example #23
0
  private static Request transformRequest(HttpRequest request, Object tag) {
    Request.Builder builder = new Request.Builder();

    RequestLine requestLine = request.getRequestLine();
    String method = requestLine.getMethod();
    builder.url(requestLine.getUri());

    String contentType = null;
    for (Header header : request.getAllHeaders()) {
      String name = header.getName();
      if ("Content-Type".equals(name)) {
        contentType = header.getValue();
      } else {
        builder.header(name, header.getValue());
      }
    }

    RequestBody body = null;
    if (request instanceof HttpEntityEnclosingRequest) {
      HttpEntity entity = ((HttpEntityEnclosingRequest) request).getEntity();
      if (entity != null) {
        // Wrap the entity in a custom Body which takes care of the content, length, and type.
        body = new HttpEntityBody(entity, contentType);

        Header encoding = entity.getContentEncoding();
        if (encoding != null) {
          builder.header(encoding.getName(), encoding.getValue());
        }
      }
    }
    builder.method(method, body);
    builder.tag(tag);

    return builder.build();
  }
 public KoalaDownloadTask build() {
   Map<String, String> params = new HashMap<String, String>();
   Map<String, String> headers = new HashMap<String, String>();
   Request.Builder builder = new Request.Builder();
   if (task.req != null) {
     KoalaHttpType type = task.req.getClass().getAnnotation(KoalaHttpType.class);
     if (type != null) {
       KoalaHttpUtils.getParams(task.req, task.req.getClass(), params, headers);
       if (headers.size() > 0) {
         Set<Map.Entry<String, String>> set = params.entrySet();
         Iterator<Map.Entry<String, String>> iterator = set.iterator();
         while (iterator.hasNext()) {
           Map.Entry<String, String> maEntry = iterator.next();
           builder.addHeader(maEntry.getKey(), maEntry.getValue());
         }
       }
       if (params.size() > 0) {
         if (type.value() == KoalaRequestType.GET) {
           task.url += ("?" + KoalaHttpUtils.getNameValuePair(params));
         } else if (type.value() == KoalaRequestType.POST) {
           Set<Map.Entry<String, String>> set = params.entrySet();
           Iterator<Map.Entry<String, String>> iterator = set.iterator();
           FormEncodingBuilder bodyBuilder = new FormEncodingBuilder();
           while (iterator.hasNext()) {
             Map.Entry<String, String> maEntry = iterator.next();
             bodyBuilder.add(maEntry.getKey(), maEntry.getValue());
           }
           builder.post(bodyBuilder.build());
         }
       }
     }
     task.url = KoalaHttpUtils.buildUrl(task.url, task.req);
     KoalaRequestTag tag = task.req.getClass().getAnnotation(KoalaRequestTag.class);
     if (tag != null) {
       if (TextUtils.isEmpty(tag.value())) {
         builder.tag(SecurityMD5.ToMD5(task.url));
       } else {
         builder.tag(tag);
       }
     } else {
       builder.tag(SecurityMD5.ToMD5(task.url));
     }
   } else {
     builder.tag(SecurityMD5.ToMD5(task.url));
   }
   builder.url(task.url);
   task.request = builder.build();
   task.tag = task.request.tag();
   return task;
 }
 @Override
 public Response intercept(Chain chain) throws IOException {
   Request request = chain.request();
   Optional<String> appAuthHeader = Optional.fromNullable(request.header(X_API_KEY_HEADER));
   if (appAuthHeader.isPresent()) {
     final Request.Builder newRequest = request.newBuilder();
     final String today = getTodayDate();
     newRequest.addHeader(DATE_HEADER, today);
     Signature signature =
         getSigner()
             .sign(
                 request.method(),
                 request.urlString(),
                 Collections.singletonMap(DATE_HEADER, today));
     newRequest.addHeader(AUTHORIZATION_HEADER, signature.toString());
     request = newRequest.build();
   }
   return chain.proceed(request);
 }
 /** POST request set up for making authorization calls */
 public void authCall(
     String url,
     LinkedHashMap<String, String> body,
     HashMap<String, String> headerMap,
     Callback callback) {
   OkHttpClient client = new OkHttpClient();
   Request.Builder requestBuilder = new Request.Builder();
   for (Map.Entry<String, String> entry : headerMap.entrySet()) {
     requestBuilder.addHeader(entry.getKey(), entry.getValue());
   }
   Request request = null;
   MediaType mediaType = MEDIA_TYPE_MARKDOWN;
   String bodyString = getBodyString(body, mediaType);
   HashMap<String, String> options = new HashMap<>();
   options.put("addServer", "true");
   String apiUrl = apiURL(url, options);
   request = requestBuilder.url(apiUrl).post(RequestBody.create(mediaType, bodyString)).build();
   client.newCall(request).enqueue(callback);
 }
Example #27
0
    @Override
    protected String doInBackground(String... params) {
      OkHttpClient okHttpClient = new OkHttpClient();

      Request.Builder builder = new Request.Builder();
      Request request = builder.url("http://192.168.1.94/check2.php").build();

      try {
        Response response = okHttpClient.newCall(request).execute();
        if (response.isSuccessful()) {
          return response.body().string();
        } else {
          return "Not Success - code : " + response.code();
        }
      } catch (IOException e) {
        e.printStackTrace();
        return "Error - " + e.getMessage();
      }
    }
 protected void populateHeaders(HttpRequest request, Request.Builder builder) {
   // OkHttp does not set the Accept header if not present in the request.
   // Make sure we send a flexible one.
   if (request.getFirstHeaderOrNull(ACCEPT) == null) {
     builder.addHeader(ACCEPT, "*/*");
   }
   if (request.getFirstHeaderOrNull(USER_AGENT) == null) {
     builder.addHeader(USER_AGENT, DEFAULT_USER_AGENT);
   }
   for (Map.Entry<String, String> entry : request.getHeaders().entries()) {
     builder.addHeader(entry.getKey(), entry.getValue());
   }
   if (request.getPayload() != null) {
     MutableContentMetadata md = request.getPayload().getContentMetadata();
     for (Map.Entry<String, String> entry : contentMetadataCodec.toHeaders(md).entries()) {
       builder.addHeader(entry.getKey(), entry.getValue());
     }
   }
 }
Example #29
0
  public static @NonNull SmashNetworkData perform(SmashRequest<?> request) throws SmashError {
    SmashNetworkData data = new SmashNetworkData();

    try {
      Request.Builder okBuilder = new Request.Builder().url(request.getUrl());
      okBuilder.removeHeader("User-Agent").addHeader("User-Agent", Smash.getUserAgent());

      BufferedSource body = getBody(request);
      switch (request.getMethod()) {
        case GET:
          okBuilder = okBuilder.get();
          break;
        case POST:
          okBuilder = okBuilder.post(convertBody(request, body));
          break;
        case PUT:
          okBuilder = okBuilder.put(convertBody(request, body));
          break;
        case DELETE:
          okBuilder = okBuilder.delete(convertBody(request, body));
          break;
        case HEAD:
          okBuilder = okBuilder.head();
          break;
        case PATCH:
          okBuilder = okBuilder.patch(convertBody(request, body));
          break;
      }

      Request okRequest = okBuilder.build();
      Response okResponse = sHttpClient.newCall(okRequest).execute();

      if (body != null) {
        body.close();
      }

      data.code = okResponse.code();
      data.headers = okResponse.headers();
      data.source = okResponse.body().source();
      data.length = okResponse.body().contentLength();
    } catch (IOException ioe) {
      throw new SmashError(ioe);
    }

    return data;
  }
Example #30
0
 public boolean loginAs(String username) {
   ContentValues values = new ContentValues();
   values.put(APIConstants.PARAMETER_USER, username);
   String urlString = APIConstants.URL_LOGINAS + "?" + builderGetParametersString(values);
   Log.i(this.getClass().getName(), "doing superuser swap: " + urlString);
   // This API returns a redirect that means the call worked, but we do not want to follow it.  To
   // just get the cookie from the 302 and stop, we directly use a one-off OkHttpClient.
   Request.Builder requestBuilder = new Request.Builder().url(urlString);
   addCookieHeader(requestBuilder);
   OkHttpClient noredirHttpClient = new OkHttpClient();
   noredirHttpClient.setFollowRedirects(false);
   try {
     Response response = noredirHttpClient.newCall(requestBuilder.build()).execute();
     if (!response.isRedirect()) return false;
     String newCookie = response.header("Set-Cookie");
     PrefsUtils.saveLogin(context, username, newCookie);
   } catch (IOException ioe) {
     return false;
   }
   return true;
 }