@Override public OutputStream get() { String expanded = repositoryURL.toString() + "/repo/sendobject"; try { HttpURLConnection connection = (HttpURLConnection) new URL(expanded).openConnection(); connection.setDoOutput(true); connection.setDoInput(true); connection.setUseCaches(false); connection.setRequestMethod("POST"); connection.setChunkedStreamingMode(4096); connection.setRequestProperty("content-length", "-1"); connection.setRequestProperty("content-encoding", "gzip"); OutputStream out = connection.getOutputStream(); final ReportingOutputStream rout = HttpUtils.newReportingOutputStream(connection, out, true); return new FilterOutputStream(rout) { @Override public void close() throws IOException { super.close(); compressedSize += ((ReportingOutputStream) super.out).compressedSize(); uncompressedSize += ((ReportingOutputStream) super.out).unCompressedSize(); } }; } catch (Exception e) { throw Throwables.propagate(e); } }
static void setContentTypeAndLengthForStreaming( HttpURLConnection connection, Request request, boolean compress) { long length; if (request.payload instanceof File) { length = compress ? -1L : ((File) request.payload).length(); } else if (request.payload instanceof InputStream) { length = -1L; } else { throw new IllegalStateException(); } if (length > Integer.MAX_VALUE) { length = -1L; // use chunked streaming mode } WebbUtils.ensureRequestProperty(connection, Const.HDR_CONTENT_TYPE, Const.APP_BINARY); if (length < 0) { connection.setChunkedStreamingMode(-1); // use default chunk size if (compress) { connection.setRequestProperty(Const.HDR_CONTENT_ENCODING, "gzip"); } } else { connection.setFixedLengthStreamingMode((int) length); } }
void prepareRequest(HttpURLConnection connection, Request request) throws IOException { // HttpURLConnection artificially restricts request method try { connection.setRequestMethod(request.getMethod()); } catch (ProtocolException e) { try { methodField.set(connection, request.getMethod()); } catch (IllegalAccessException e1) { throw RetrofitError.unexpectedError(request.getUrl(), e1); } } connection.setDoInput(true); for (Header header : request.getHeaders()) { connection.addRequestProperty(header.getName(), header.getValue()); } TypedOutput body = request.getBody(); if (body != null) { connection.setDoOutput(true); connection.addRequestProperty("Content-Type", body.mimeType()); long length = body.length(); if (length != -1) { connection.setFixedLengthStreamingMode((int) length); connection.addRequestProperty("Content-Length", String.valueOf(length)); } else { connection.setChunkedStreamingMode(CHUNK_SIZE); } body.writeTo(connection.getOutputStream()); } }
@Override public void setHeaders( List<NameValue> requestHeaders, boolean isFixedLengthStreamingMode, long totalBodyBytes) throws IOException { if (isFixedLengthStreamingMode) { if (android.os.Build.VERSION.SDK_INT >= 19) { mConnection.setFixedLengthStreamingMode(totalBodyBytes); } else { if (totalBodyBytes > Integer.MAX_VALUE) throw new RuntimeException( "You need Android API version 19 or newer to " + "upload more than 2GB in a single request using " + "fixed size content length. Try switching to " + "chunked mode instead, but make sure your server side supports it!"); mConnection.setFixedLengthStreamingMode((int) totalBodyBytes); } } else { mConnection.setChunkedStreamingMode(0); } for (final NameValue param : requestHeaders) { mConnection.setRequestProperty(param.getName(), param.getValue()); } }
public static final HTTPStream createHTTPStream( String address, boolean isPost, byte[] postData, String headers, int timeOutMs, java.lang.StringBuffer responseHeaders) { try { HttpURLConnection connection = (HttpURLConnection) (new URL(address).openConnection()); if (connection != null) { try { if (isPost) { connection.setConnectTimeout(timeOutMs); connection.setDoOutput(true); connection.setChunkedStreamingMode(0); OutputStream out = connection.getOutputStream(); out.write(postData); out.flush(); } return new HTTPStream(connection); } catch (Throwable e) { connection.disconnect(); } } } catch (Throwable e) { } return null; }
/** * 根据 url获取HttpURLConnection 对象 * * @param SERVER_URL API的地址 * @return */ private HttpURLConnection getConnection(String SERVER_URL) { HttpURLConnection connection = null; // 初始化connection try { // 根据地址创建URL对象 URL url = new URL(SERVER_URL); // 根据URL对象打开链接 connection = (HttpURLConnection) url.openConnection(); // 设置请求的方式 connection.setRequestMethod(REQUEST_MOTHOD); // 发送POST请求必须设置允许输入,默认为true connection.setDoInput(true); // 发送POST请求必须设置允许输出 connection.setDoOutput(true); // 设置不使用缓存 connection.setUseCaches(false); // 设置请求的超时时间 connection.setReadTimeout(TIME_OUT); connection.setConnectTimeout(TIME_OUT); connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded"); connection.setRequestProperty("Connection", "keep-alive"); connection.setRequestProperty("Response-Type", "json"); connection.setChunkedStreamingMode(0); } catch (IOException e) { e.printStackTrace(); } return connection; }
public HTTPForm(URL form) throws IOException { connection = (HttpURLConnection) form.openConnection(); connection.setChunkedStreamingMode(1024 * 64); connection.setDoOutput(true); connection.setRequestProperty("Content-Type", "multipart/form-data; boundary=" + boundary); this.out = connection.getOutputStream(); }
public static void configConnection(HttpURLConnection connection) throws ProtocolException { connection.setConnectTimeout(5000); connection.setDoOutput(true); connection.setDoInput(true); connection.setChunkedStreamingMode(0); connection.setRequestMethod("POST"); connection.setRequestProperty("Content-Type", "application/json;charset=utf-8"); connection.setUseCaches(false); }
public void uploadFile() throws IOException { String fileName = url.path().toString(); DataOutputStream dos = null; String lineEnd = "\r\n"; String twoHyphens = "--"; String boundary = "*****"; int bytesRead, bytesAvailable, bufferSize; byte[] buffer; int maxBufferSize = 1 * 1024 * 1024; FileInputStream fileInputStream = new FileInputStream(fileName); // Open a HTTP connection to the URL request = (HttpURLConnection) url.getUrl().openConnection(); request.setDoInput(true); // Allow Inputs request.setDoOutput(true); // Allow Outputs request.setUseCaches(false); // Don't use a Cached Copy request.setChunkedStreamingMode(1024); request.setRequestMethod("POST"); request.setRequestProperty("requestection", "Keep-Alive"); request.setRequestProperty("ENCTYPE", "multipart/form-data"); request.setRequestProperty("Content-Type", "multipart/form-data;boundary=" + boundary); request.setRequestProperty("uploaded_file", fileName); dos = new DataOutputStream(request.getOutputStream()); dos.writeBytes(twoHyphens + boundary + lineEnd); dos.writeBytes( "Content-Disposition: form-data; name=\"file\";filename=\"" + fileName + "\"" + lineEnd); dos.writeBytes(lineEnd); // create a buffer of maximum size bytesAvailable = fileInputStream.available(); bufferSize = Math.min(bytesAvailable, maxBufferSize); buffer = new byte[bufferSize]; // read file and write it into form... bytesRead = fileInputStream.read(buffer, 0, bufferSize); while (bytesRead > 0) { dos.write(buffer, 0, bufferSize); bytesAvailable = fileInputStream.available(); bufferSize = Math.min(bytesAvailable, maxBufferSize); bytesRead = fileInputStream.read(buffer, 0, bufferSize); } // send multipart form data necesssary after file data... dos.writeBytes(lineEnd); dos.writeBytes(twoHyphens + boundary + twoHyphens + lineEnd); // close the streams // fileInputStream.close(); dos.flush(); dos.close(); }
/** * This method is responsible to prepare a PUT request to add documents to an existing collection. * * @param collection Collection name. * @param name The name of the collection. * @throws IOException Exception occurred. */ public void initAdd(final String collection, final String name) throws IOException { URL url = new URL(mServers[0] + "/" + collection + "/" + name); HttpURLConnection conn = (HttpURLConnection) url.openConnection(); conn.setDoOutput(true); conn.setRequestMethod(PUT); conn.setRequestProperty(CONTENT_TYPE_STRING, TEXT_XML); conn.setChunkedStreamingMode(1); OutputStream out = new BufferedOutputStream(conn.getOutputStream()); mOutput = out; this.mConn = conn; }
/** * @param uploadUrl * @param srcPath * @return */ public static String uploadFile(String uploadUrl, String srcPath) { String end = "\r\n"; String twoHyphens = "--"; String boundary = "******"; try { URL url = new URL(uploadUrl); HttpURLConnection httpURLConnection = (HttpURLConnection) url.openConnection(); // 设置每次传输的流大小,可以有效防止手机因为内存不足崩溃 // 此方法用于在预先不知道内容长度时启用没有进行内部缓冲的 HTTP 请求正文的流。 httpURLConnection.setChunkedStreamingMode(128 * 1024); // 128K // 允许输入输出流 httpURLConnection.setDoInput(true); httpURLConnection.setDoOutput(true); httpURLConnection.setUseCaches(false); // 使用POST方法 httpURLConnection.setRequestMethod("POST"); httpURLConnection.setRequestProperty("Connection", "Keep-Alive"); httpURLConnection.setRequestProperty("Charset", "UTF-8"); httpURLConnection.setRequestProperty( "Content-Type", "multipart/form-data;boundary=" + boundary); DataOutputStream dos = new DataOutputStream(httpURLConnection.getOutputStream()); dos.writeBytes(twoHyphens + boundary + end); dos.writeBytes( "Content-Disposition: form-data; name=\"myFile\"; filename=\"" + URLEncoder.encode(srcPath.substring(srcPath.lastIndexOf("/") + 1)) + "\"" + end); dos.writeBytes(end); FileInputStream fis = new FileInputStream(srcPath); byte[] buffer = new byte[8192]; // 8k int count = 0; // 读取文件 while ((count = fis.read(buffer)) != -1) { dos.write(buffer, 0, count); } fis.close(); dos.writeBytes(end); dos.writeBytes(twoHyphens + boundary + twoHyphens + end); dos.flush(); InputStream is = httpURLConnection.getInputStream(); InputStreamReader isr = new InputStreamReader(is, "utf-8"); BufferedReader br = new BufferedReader(isr); String result = br.readLine(); dos.close(); is.close(); return result; } catch (Exception e) { e.printStackTrace(); return null; } }
private OutputStream connectRaw( String uri, HashMap<String, String> httpHeaders, boolean enableCompression) throws IOException { url = new URL(uri); connection = createConnection(config, url, httpHeaders, enableCompression); connection.setRequestMethod("POST"); connection.setDoInput(true); connection.setDoOutput(true); if (config.useChunkedPost()) { connection.setChunkedStreamingMode(4096); } return connection.getOutputStream(); }
private static void putVMFiles(String remoteFilePath, String localFilePath) throws Exception { String serviceUrl = url.substring(0, url.lastIndexOf("sdk") - 1); String httpUrl = serviceUrl + "/folder" + remoteFilePath + "?dcPath=" + datacenter + "&dsName=" + datastore; httpUrl = httpUrl.replaceAll("\\ ", "%20"); System.out.println("Putting VM File " + httpUrl); URL fileURL = new URL(httpUrl); HttpURLConnection conn = (HttpURLConnection) fileURL.openConnection(); conn.setDoInput(true); conn.setDoOutput(true); conn.setAllowUserInteraction(true); // Maintain session List cookies = (List) headers.get("Set-cookie"); cookieValue = (String) cookies.get(0); StringTokenizer tokenizer = new StringTokenizer(cookieValue, ";"); cookieValue = tokenizer.nextToken(); String path = "$" + tokenizer.nextToken(); String cookie = "$Version=\"1\"; " + cookieValue + "; " + path; // set the cookie in the new request header Map map = new HashMap(); map.put("Cookie", Collections.singletonList(cookie)); ((BindingProvider) vimPort).getRequestContext().put(MessageContext.HTTP_REQUEST_HEADERS, map); conn.setRequestProperty("Cookie", cookie); conn.setRequestProperty("Content-Type", "application/octet-stream"); conn.setRequestMethod("PUT"); conn.setRequestProperty("Content-Length", "1024"); long fileLen = new File(localFilePath).length(); System.out.println("File size is: " + fileLen); conn.setChunkedStreamingMode((int) fileLen); OutputStream out = conn.getOutputStream(); InputStream in = new BufferedInputStream(new FileInputStream(localFilePath)); int bufLen = 9 * 1024; byte[] buf = new byte[bufLen]; byte[] tmp = null; int len = 0; while ((len = in.read(buf, 0, bufLen)) != -1) { tmp = new byte[len]; System.arraycopy(buf, 0, tmp, 0, len); out.write(tmp, 0, len); } in.close(); out.close(); conn.getResponseMessage(); conn.disconnect(); }
@Override public String doInBackground(JSONObject... params) { HttpURLConnection urlConnection = null; String answer = null; URL url = null; try { url = new URL("http://folk.ntnu.no/thomborr/NoTheftAuto/deleteCar.php"); String message = params[0].toString(); urlConnection = (HttpURLConnection) url.openConnection(); // Setter at jeg kan sende data til serveren urlConnection.setDoOutput(true); // Setter at jeg kan motta data fra serveren urlConnection.setDoInput(true); // Gj�r noe med byte-streamen s� ikke hele lagres i minnet samtidig (?) urlConnection.setChunkedStreamingMode(0); // Setter request method til POST urlConnection.setReadTimeout(10000 /*milliseconds*/); urlConnection.setConnectTimeout(15000 /* milliseconds */); urlConnection.setRequestMethod("POST"); urlConnection.setRequestProperty("Content-Type", "application/json; charset=UTF-8"); urlConnection.setRequestProperty("X-Requested-With", "XMLHttpRequest"); // Send request OutputStream out = new BufferedOutputStream(urlConnection.getOutputStream()); out.write(message.getBytes()); // clean up out.flush(); out.close(); // Receive answer InputStream in = new BufferedInputStream(urlConnection.getInputStream()); answer = convertStreamToString(in); in.close(); } catch (Exception e) { e.printStackTrace(); } finally { if (urlConnection != null) { urlConnection.disconnect(); } } return answer; }
public static HttpURLConnection createConnection(String method, UrlCreator urlCreator) { HttpURLConnection connection = null; try { URL url = urlCreator.createURL(); connection = (HttpURLConnection) url.openConnection(); connection.setRequestMethod(method); connection.setDoInput(true); connection.setChunkedStreamingMode(0); } catch (IOException e) { e.printStackTrace(); if (connection != null) { connection.disconnect(); } } return connection; }
@Override protected String doInBackground(InputStream... speech) { String response = null; try { Log.d("Wit", "Requesting SPEECH ...." + _contentType); WitRequest witRequest = new WitRequest(_witListener, _context); String urlStr = witRequest.buildUri("speech").build().toString(); URL url = new URL(urlStr); Log.d("Wit", "Posting speech to " + url.toString()); HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection(); urlConnection.setDoOutput(true); urlConnection.setRequestProperty( AUTHORIZATION_HEADER, String.format(BEARER_FORMAT, _accessToken)); urlConnection.setRequestProperty(ACCEPT_HEADER, ACCEPT_VERSION); urlConnection.setRequestProperty(CONTENT_TYPE_HEADER, _contentType); urlConnection.setRequestProperty(TRANSFER_ENCODING_HEADER, "chunked"); urlConnection.setChunkedStreamingMode(0); try { OutputStream out = urlConnection.getOutputStream(); int n; byte[] buffer = new byte[1024]; while ((n = speech[0].read(buffer)) > -1) { out.write(buffer, 0, n); // Don't allow any extra bytes to creep in, final write } out.close(); Log.d("Wit", "Done sending data"); int statusCode = urlConnection.getResponseCode(); InputStream in; if (statusCode != 200) { in = urlConnection.getErrorStream(); } else { in = new BufferedInputStream(urlConnection.getInputStream()); } response = IOUtils.toString(in); in.close(); } finally { urlConnection.disconnect(); } } catch (Exception e) { Log.d("Wit", "An error occurred during the request: " + e.getMessage()); } return response; }
public void uploadData() throws IOException { DataOutputStream dos; request.setDoInput(true); // Allow Inputs request.setDoOutput(true); // Allow Outputs request.setUseCaches(false); // Don't use a Cached Copy request.setChunkedStreamingMode(1024); request.setRequestMethod("POST"); request.setRequestProperty("connection", "Keep-Alive"); request.setRequestProperty("ENCTYPE", "multipart/form-data"); dos = new DataOutputStream(request.getOutputStream()); byte[] databyte = data.bytes(); dos.write(databyte); dos.flush(); dos.close(); }
void prepareRequest(HttpURLConnection connection, Request request) throws IOException { connection.setRequestMethod(request.getMethod()); connection.setDoInput(true); for (Header header : request.getHeaders()) { connection.addRequestProperty(header.getName(), header.getValue()); } TypedOutput body = request.getBody(); if (body != null) { connection.setDoOutput(true); connection.addRequestProperty("Content-Type", body.mimeType()); long length = body.length(); if (length != -1) { connection.setFixedLengthStreamingMode((int) length); connection.addRequestProperty("Content-Length", String.valueOf(length)); } else { connection.setChunkedStreamingMode(CHUNK_SIZE); } body.writeTo(connection.getOutputStream()); } }
@Override public void createConnection(String conType) { try { InputStream inputStream = null; setUpHttpsConnection(); // set up the request header URL urlToConnect = new URL(networkConnection.url); httpsURLConnection = (HttpURLConnection) urlToConnect.openConnection(); setUpHttpsRequestHeader(httpsURLConnection); setRequestMethod(conType); httpsURLConnection.setConnectTimeout(TIMEOUT_DURATION); // httpsURLConnection.setDoInput(true); httpsURLConnection.setChunkedStreamingMode(0); // Connect to the server. httpsURLConnection.connect(); // write output stream the client info. if (networkConnection.datatowrite != null && networkConnection.datatowrite.length > 0) { OutputStream outputStream = null; try { outputStream = httpsURLConnection.getOutputStream(); outputStream.write(networkConnection.datatowrite); } catch (Exception e) { } finally { try { if (outputStream != null) { outputStream.close(); outputStream = null; // release resource for GC // support } } catch (IOException e) { // if unable to close the stream outputStream = null; // release resource for GC } } networkConnection.datatowrite = null; } // get teh response code int responseCode = httpsURLConnection.getResponseCode(); if (responseCode == HttpURLConnection.HTTP_OK) { // read the data stream from the network. inputStream = httpsURLConnection.getInputStream(); DataInputStream dataInputStream = new DataInputStream(inputStream); int a = -1; byte b[] = new byte[1024]; ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(); while ((a = dataInputStream.read(b)) != -1) { byteArrayOutputStream.write(b, 0, a); } // Set the data into the networkUpdater networkConnection.networkStatus.setServerResponseData(byteArrayOutputStream.toByteArray()); networkConnection.networkStatus.setNetworkConnectionException(null); byteArrayOutputStream.close(); dataInputStream.close(); httpsURLConnection.disconnect(); } else { // Something went wrong setErrorMessage(responseCode); httpsURLConnection.disconnect(); networkConnection.networkStatus.setServerResponseData(null); networkConnection.networkStatus.setNetworkError(true); // networkConnection.networkStatus.setNetorkErrorMessage(); } } catch (Exception e) { // Something went wrong // setErrorMessage(httpsURLConnection); networkConnection.networkStatus.setServerResponseData(null); networkConnection.networkStatus.setNetworkConnectionException(e); networkConnection.networkStatus.setNetworkError(true); } finally { if (byteArrayOutputStream != null) { try { byteArrayOutputStream.close(); } catch (IOException e) { } byteArrayOutputStream = null; } if (dataInputStream != null) { try { dataInputStream.close(); } catch (IOException e) { } dataInputStream = null; } if (httpsURLConnection != null) { httpsURLConnection.disconnect(); httpsURLConnection = null; } } }
@Override protected HttpURLConnection convert(HttpRequest request) throws IOException, InterruptedException { boolean chunked = "chunked".equals(request.getFirstHeaderOrNull("Transfer-Encoding")); URL url = request.getEndpoint().toURL(); HttpURLConnection connection = (HttpURLConnection) url.openConnection(proxyForURI.apply(request.getEndpoint())); if (connection instanceof HttpsURLConnection) { HttpsURLConnection sslCon = (HttpsURLConnection) connection; if (utils.relaxHostname()) sslCon.setHostnameVerifier(verifier); if (sslContextSupplier != null) { // used for providers which e.g. use certs for authentication (like FGCP) // Provider provides SSLContext impl (which inits context with key manager) sslCon.setSSLSocketFactory(sslContextSupplier.get().getSocketFactory()); } else if (utils.trustAllCerts()) { sslCon.setSSLSocketFactory(untrustedSSLContextProvider.get().getSocketFactory()); } } connection.setConnectTimeout(utils.getConnectionTimeout()); connection.setReadTimeout(utils.getSocketOpenTimeout()); connection.setAllowUserInteraction(false); // do not follow redirects since https redirects don't work properly // ex. Caused by: java.io.IOException: HTTPS hostname wrong: should be // <adriancole.s3int0.s3-external-3.amazonaws.com> connection.setInstanceFollowRedirects(false); try { connection.setRequestMethod(request.getMethod()); } catch (ProtocolException e) { try { methodField.set(connection, request.getMethod()); } catch (IllegalAccessException e1) { logger.error(e, "could not set request method: ", request.getMethod()); propagate(e1); } } for (Map.Entry<String, String> entry : request.getHeaders().entries()) { connection.setRequestProperty(entry.getKey(), entry.getValue()); } String host = request.getEndpoint().getHost(); if (request.getEndpoint().getPort() != -1) { host += ":" + request.getEndpoint().getPort(); } connection.setRequestProperty(HOST, host); if (connection.getRequestProperty(USER_AGENT) == null) { connection.setRequestProperty(USER_AGENT, DEFAULT_USER_AGENT); } Payload payload = request.getPayload(); if (payload != null) { MutableContentMetadata md = payload.getContentMetadata(); for (Map.Entry<String, String> entry : contentMetadataCodec.toHeaders(md).entries()) { connection.setRequestProperty(entry.getKey(), entry.getValue()); } if (chunked) { connection.setChunkedStreamingMode(8196); writePayloadToConnection(payload, "streaming", connection); } else { Long length = checkNotNull(md.getContentLength(), "payload.getContentLength"); // http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6755625 checkArgument( length < Integer.MAX_VALUE, "JDK 1.6 does not support >2GB chunks. Use chunked encoding, if possible."); if (length > 0) { connection.setRequestProperty(CONTENT_LENGTH, length.toString()); connection.setFixedLengthStreamingMode(length.intValue()); writePayloadToConnection(payload, length, connection); } else { writeNothing(connection); } } } else { writeNothing(connection); } return connection; }
public Response executeTask() throws Exception { if (lite.isCacheAble(this)) lite.addCacheHeaders(request); String urlStr = request.getUrl(); URL url = new URL(urlStr); HttpURLConnection connection; if (lite.settings.getProxy() != null) { connection = (HttpURLConnection) url.openConnection(lite.settings.getProxy()); } else { connection = (HttpURLConnection) url.openConnection(); } assertCanceled(); connection.setReadTimeout(lite.settings.getReadTimeout()); connection.setConnectTimeout(lite.settings.getConnectTimeout()); connection.setInstanceFollowRedirects(lite.settings.isFollowRedirects()); if (connection instanceof HttpsURLConnection) { HttpsURLConnection httpsURLConnection = (HttpsURLConnection) connection; httpsURLConnection.setSSLSocketFactory(lite.settings.getSslSocketFactory()); httpsURLConnection.setHostnameVerifier(lite.settings.getHostnameVerifier()); } lite.processCookie(urlStr, request.getHeaders()); if (request.getHeaders() != null && !request.getHeaders().isEmpty()) { boolean first; for (String name : request.getHeaders().keySet()) { first = true; for (String value : request.getHeaders().get(name)) { if (first) { connection.setRequestProperty(name, value); first = false; } else { connection.addRequestProperty(name, value); } } } } connection.setRequestMethod(request.getMethod().name()); connection.setDoInput(true); if (request.getMethod().permitsRequestBody && request.getBody() != null) { connection.setRequestProperty("Content-Type", request.getBody().contentType().toString()); long contentLength = request.getBody().contentLength(); if (contentLength < 0) { connection.setChunkedStreamingMode(256 * 1024); } else { if (contentLength < Integer.MAX_VALUE) { connection.setFixedLengthStreamingMode((int) contentLength); } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) { connection.setFixedLengthStreamingMode(contentLength); } else { connection.setChunkedStreamingMode(256 * 1024); } } connection.setRequestProperty("Content-Length", String.valueOf(contentLength)); connection.setDoOutput(true); request.getBody().writeTo(connection.getOutputStream()); } Response response = URLite.createResponse(connection, request); lite.saveCookie(urlStr, response.headers()); isExecuted = true; if (!lite.isCacheAble(this)) { return response; } else { return lite.createCacheResponse(response); } }
@Override public void setChunkedStreamingMode(int chunklen) { super.setChunkedStreamingMode(chunklen); }
/** * invoke via Loader * * @throws IOException */ @Override @TargetApi(Build.VERSION_CODES.KITKAT) public void sendRequest() throws IOException { isLoading = false; URL url = new URL(queryUrl); { // init connection Proxy proxy = params.getProxy(); if (proxy != null) { connection = (HttpURLConnection) url.openConnection(proxy); } else { connection = (HttpURLConnection) url.openConnection(); } connection.setInstanceFollowRedirects(true); connection.setReadTimeout(params.getConnectTimeout()); connection.setConnectTimeout(params.getConnectTimeout()); if (connection instanceof HttpsURLConnection) { ((HttpsURLConnection) connection).setSSLSocketFactory(params.getSslSocketFactory()); } } { // add headers try { Map<String, List<String>> singleMap = COOKIE_MANAGER.get(url.toURI(), new HashMap<String, List<String>>(0)); List<String> cookies = singleMap.get("Cookie"); if (cookies != null) { connection.setRequestProperty("Cookie", TextUtils.join(";", cookies)); } } catch (Throwable ex) { LogUtil.e(ex.getMessage(), ex); } HashMap<String, String> headers = params.getHeaders(); if (headers != null) { for (Map.Entry<String, String> entry : headers.entrySet()) { String name = entry.getKey(); String value = entry.getValue(); if (!TextUtils.isEmpty(name) && !TextUtils.isEmpty(value)) { connection.setRequestProperty(name, value); } } } } { // write body HttpMethod method = params.getMethod(); connection.setRequestMethod(method.toString()); if (HttpMethod.permitsRequestBody(method)) { RequestBody body = params.getRequestBody(); if (body != null) { if (body instanceof ProgressBody) { ((ProgressBody) body).setProgressHandler(progressHandler); } String contentType = body.getContentType(); if (!TextUtils.isEmpty(contentType)) { connection.setRequestProperty("Content-Type", contentType); } long contentLength = body.getContentLength(); if (contentLength < 0) { connection.setChunkedStreamingMode(256 * 1024); } else { if (contentLength < Integer.MAX_VALUE) { connection.setFixedLengthStreamingMode((int) contentLength); } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) { connection.setFixedLengthStreamingMode(contentLength); } else { connection.setChunkedStreamingMode(256 * 1024); } } connection.setRequestProperty("Content-Length", String.valueOf(contentLength)); connection.setDoOutput(true); body.writeTo(connection.getOutputStream()); } } } LogUtil.d(queryUrl); int code = connection.getResponseCode(); if (code >= 300) { HttpException httpException = new HttpException(code, connection.getResponseMessage()); try { httpException.setResult(IOUtil.readStr(connection.getInputStream(), params.getCharset())); } catch (Throwable ignored) { } throw httpException; } { // save cookies try { Map<String, List<String>> headers = connection.getHeaderFields(); if (headers != null) { COOKIE_MANAGER.put(url.toURI(), headers); } } catch (Throwable ex) { LogUtil.e(ex.getMessage(), ex); } } isLoading = true; }
public void setChunkedStreamingMode(int i) { _flddelegate.setChunkedStreamingMode(i); }
/** * Set chunked encoding for the file to be uploaded. This avoid the output stream to buffer all * data before transmitting it. * * @param chunkLength the length of the single chunk */ public void setChunkedStreamingMode(int chunkLength) throws IOException { if (conn == null) { throw new IOException("Cannot open output stream on non opened connection"); } conn.setChunkedStreamingMode(chunkLength); }