Comments (12)
The above commit should make it possible to depend on Volley without having to declare a dependency on the Apache HTTP client via the approach I outlined above as long as you're using HurlStack or another stack which doesn't depend on the Apache HTTP library (in which case you'll need to make a small tweak to extend from BaseHttpStack instead of implementing HttpStack). In my testing, the Android build tools seem to call proguard with the Apache JAR in the classpath even though the app never asked for it, so we may not have to do any proguard hacks at this point. That being said, it'd be very helpful for other app developers to try this approach to see if it meets their needs and works with their build.
If you'd like to test this, you can either patch in this change and build from source, or try this compiled aar library by unzipping the .aar file inside, putting it in your tree (say aar/) and adding this to build.gradle in place of any existing Volley dependency:
repositories {
flatDir {
dirs 'aar'
}
}
dependencies {
compile 'com.android.volley:volley-release:1.0@aar'
}
If this works well for folks, I'll move forward with getting this merged and released.
from volley.
Sure - what I mean is that there are existing apps which depend on Volley with their own subclasses of HttpStack and/or Request. If we change those classes in an incompatible way, e.g. by changing the return type of HttpStack#performRequest from HttpResponse to URLConnection, those apps will no longer compile when they upgrade.
This is painful to developers, so it's something we generally like to avoid if at all possible. At the very least, we like to provide a transition period for apps to move off the broken APIs before we remove them.
So I'm hoping that instead of just changing the library's public method signatures, we can keep the old ones, but deprecate them and add new ones to replace them.
from volley.
In my humble opinion, doing a major version bump worth it. Also I think that this change is really important, since HttpClient has been deprecated 2 APIs ago and in some future it may become unavailable at all.
from volley.
@jpd236 can it be a workaround? https://github.com/ngocchung/VolleyNoApache/blob/master/app/src/main/java/com/android/volley/toolbox/HurlStack.java#119
from volley.
I'd need more details on what you're suggesting with the above, but it looks like the above code just changes the signature of HttpStack#performRequest, which is the problem noted in 1 (an API-breaking change). Doing that is the extreme option which will break every caller of Volley so like I said, I'd like to explore a more gentle approach before taking such a hard line.
from volley.
@jpd236 sorry for my bad English, can you explain more about "API-breaking change"? In the code i mentioned, not only the signatures changed, and you can see dependency removed.
from volley.
@jpd236 I got it, many thanks :)
from volley.
I think this is a right time to have 2.0 version released, which will drop HttpClient suppport and break API. It's already 17th month passed since official HttpClient deprecation. I don't think it's necessary to wait longer...
from volley.
Good to know that the dependency on Apache HttpClient is going to go.
from volley.
I have editted HurlStack class , you just need to paste it to your project and you will give totally new perspective to your users:I just added between of //************************--------------
this lines
/*
* Copyright (C) 2011 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.volley.toolbox;
import com.android.volley.AuthFailureError;
import com.android.volley.Request;
import com.android.volley.Request.Method;
import org.apache.http.Header;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.ProtocolVersion;
import org.apache.http.StatusLine;
import org.apache.http.entity.BasicHttpEntity;
import org.apache.http.message.BasicHeader;
import org.apache.http.message.BasicHttpResponse;
import org.apache.http.message.BasicStatusLine;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLSocketFactory;
/**
* An {@link HttpStack} based on {@link HttpURLConnection}.
*/
public class HurlStack implements HttpStack {
private static final String HEADER_CONTENT_TYPE = "Content-Type";
//************************--------------
//added variables and functions
HttpURLConnection httpURLConnection=null;
//below methods can be extended
public HttpURLConnection getConnectionPreExecute(HttpURLConnection connection){
return connection;
}
public HttpURLConnection getConnectionPostExecute(HttpURLConnection connection){
return connection;
}
//************************--------------
/**
* An interface for transforming URLs before use.
*/
public interface UrlRewriter {
/**
* Returns a URL to use instead of the provided one, or null to indicate
* this URL should not be used at all.
*/
String rewriteUrl(String originalUrl);
}
private final UrlRewriter mUrlRewriter;
private final SSLSocketFactory mSslSocketFactory;
public HurlStack() {
this(null);
}
/**
* @param urlRewriter Rewriter to use for request URLs
*/
public HurlStack(UrlRewriter urlRewriter) {
this(urlRewriter, null);
}
/**
* @param urlRewriter Rewriter to use for request URLs
* @param sslSocketFactory SSL factory to use for HTTPS connections
*/
public HurlStack(UrlRewriter urlRewriter, SSLSocketFactory sslSocketFactory) {
mUrlRewriter = urlRewriter;
mSslSocketFactory = sslSocketFactory;
}
@Override
public HttpResponse performRequest(Request<?> request, Map<String, String> additionalHeaders)
throws IOException, AuthFailureError {
String url = request.getUrl();
HashMap<String, String> map = new HashMap<String, String>();
map.putAll(request.getHeaders());
map.putAll(additionalHeaders);
if (mUrlRewriter != null) {
String rewritten = mUrlRewriter.rewriteUrl(url);
if (rewritten == null) {
throw new IOException("URL blocked by rewriter: " + url);
}
url = rewritten;
}
URL parsedUrl = new URL(url);
HttpURLConnection connection = openConnection(parsedUrl, request);
//**********************-------
//added
connection = getConnectionPreExecute(connection);
//**********************-------
httpURLConnection = connection;
for (String headerName : map.keySet()) {
connection.addRequestProperty(headerName, map.get(headerName));
}
setConnectionParametersForRequest(connection, request);
// Initialize HttpResponse with data from the HttpURLConnection.
ProtocolVersion protocolVersion = new ProtocolVersion("HTTP", 1, 1);
int responseCode = connection.getResponseCode();
if (responseCode == -1) {
// -1 is returned by getResponseCode() if the response code could not be retrieved.
// Signal to the caller that something was wrong with the connection.
throw new IOException("Could not retrieve response code from HttpUrlConnection.");
}
StatusLine responseStatus = new BasicStatusLine(protocolVersion,
connection.getResponseCode(), connection.getResponseMessage());
BasicHttpResponse response = new BasicHttpResponse(responseStatus);
if (hasResponseBody(request.getMethod(), responseStatus.getStatusCode())) {
response.setEntity(entityFromConnection(connection));
}
//**********************-------
//added
connection = getConnectionPostExecute(connection);
//**********************-------
for (Entry<String, List<String>> header : connection.getHeaderFields().entrySet()) {
if (header.getKey() != null) {
Header h = new BasicHeader(header.getKey(), header.getValue().get(0));
response.addHeader(h);
}
}
return response;
}
/**
* Checks if a response message contains a body.
* @see <a href="https://tools.ietf.org/html/rfc7230#section-3.3">RFC 7230 section 3.3</a>
* @param requestMethod request method
* @param responseCode response status code
* @return whether the response has a body
*/
private static boolean hasResponseBody(int requestMethod, int responseCode) {
return requestMethod != Request.Method.HEAD
&& !(HttpStatus.SC_CONTINUE <= responseCode && responseCode < HttpStatus.SC_OK)
&& responseCode != HttpStatus.SC_NO_CONTENT
&& responseCode != HttpStatus.SC_NOT_MODIFIED;
}
/**
* Initializes an {@link HttpEntity} from the given {@link HttpURLConnection}.
* @param connection
* @return an HttpEntity populated with data from <code>connection</code>.
*/
private static HttpEntity entityFromConnection(HttpURLConnection connection) {
BasicHttpEntity entity = new BasicHttpEntity();
InputStream inputStream;
try {
inputStream = connection.getInputStream();
} catch (IOException ioe) {
inputStream = connection.getErrorStream();
}
entity.setContent(inputStream);
entity.setContentLength(connection.getContentLength());
entity.setContentEncoding(connection.getContentEncoding());
entity.setContentType(connection.getContentType());
return entity;
}
/**
* Create an {@link HttpURLConnection} for the specified {@code url}.
*/
protected HttpURLConnection createConnection(URL url) throws IOException {
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
// Workaround for the M release HttpURLConnection not observing the
// HttpURLConnection.setFollowRedirects() property.
// https://code.google.com/p/android/issues/detail?id=194495
connection.setInstanceFollowRedirects(HttpURLConnection.getFollowRedirects());
return connection;
}
/**
* Opens an {@link HttpURLConnection} with parameters.
* @param url
* @return an open connection
* @throws IOException
*/
private HttpURLConnection openConnection(URL url, Request<?> request) throws IOException {
HttpURLConnection connection = createConnection(url);
int timeoutMs = request.getTimeoutMs();
connection.setConnectTimeout(timeoutMs);
connection.setReadTimeout(timeoutMs);
connection.setUseCaches(false);
connection.setDoInput(true);
// use caller-provided custom SslSocketFactory, if any, for HTTPS
if ("https".equals(url.getProtocol()) && mSslSocketFactory != null) {
((HttpsURLConnection)connection).setSSLSocketFactory(mSslSocketFactory);
}
return connection;
}
@SuppressWarnings("deprecation")
/* package */ static void setConnectionParametersForRequest(HttpURLConnection connection,
Request<?> request) throws IOException, AuthFailureError {
switch (request.getMethod()) {
case Method.DEPRECATED_GET_OR_POST:
// This is the deprecated way that needs to be handled for backwards compatibility.
// If the request's post body is null, then the assumption is that the request is
// GET. Otherwise, it is assumed that the request is a POST.
byte[] postBody = request.getPostBody();
if (postBody != null) {
connection.setRequestMethod("POST");
addBody(connection, request, postBody);
}
break;
case Method.GET:
// Not necessary to set the request method because connection defaults to GET but
// being explicit here.
connection.setRequestMethod("GET");
break;
case Method.DELETE:
connection.setRequestMethod("DELETE");
break;
case Method.POST:
connection.setRequestMethod("POST");
addBodyIfExists(connection, request);
break;
case Method.PUT:
connection.setRequestMethod("PUT");
addBodyIfExists(connection, request);
break;
case Method.HEAD:
connection.setRequestMethod("HEAD");
break;
case Method.OPTIONS:
connection.setRequestMethod("OPTIONS");
break;
case Method.TRACE:
connection.setRequestMethod("TRACE");
break;
case Method.PATCH:
connection.setRequestMethod("PATCH");
addBodyIfExists(connection, request);
break;
default:
throw new IllegalStateException("Unknown method type.");
}
}
private static void addBodyIfExists(HttpURLConnection connection, Request<?> request)
throws IOException, AuthFailureError {
byte[] body = request.getBody();
if (body != null) {
addBody(connection, request, body);
}
}
private static void addBody(HttpURLConnection connection, Request<?> request, byte[] body)
throws IOException, AuthFailureError {
// Prepare output. There is no need to set Content-Length explicitly,
// since this is handled by HttpURLConnection using the size of the prepared
// output stream.
connection.setDoOutput(true);
connection.addRequestProperty(HEADER_CONTENT_TYPE, request.getBodyContentType());
DataOutputStream out = new DataOutputStream(connection.getOutputStream());
out.write(body);
out.close();
}
}
`
```
from volley.
@NewTimeBox I don't really know how your class is related to the issue discussed here. You are just offering to add Pre and Post hooks to connection. What are you offering to do in those and how this may solve issue of Apache HttpClient dependency?
from volley.
Initial migration guide is here: https://github.com/google/volley/wiki/Migrating-from-Apache-HTTP
This should become available in an official SNAPSHOT build shortly, though the interface is subject to change until the next official release.
from volley.
Related Issues (20)
- The JsonObjectRequest and JsonArrayRequest don't support 204: No Content HOT 5
- Unexpected response code 511 for HOT 1
- Support digest authentication HOT 2
- Type com.android.volley.Cache$Entry is defined multiple times HOT 1
- Caused by: com.android.tools.r8.utils.AbortException: Error: Program type already present: com.google.android.youtube.player.YouTubeApiServiceUtil HOT 1
- Volley unable to parse dateStr HOT 1
- setPriority() for Request HOT 1
- E/Volley: [18667] NetworkUtility.shouldRetryException: Unexpected response code 403 HOT 1
- -
- Com.android.volley.2015.05.28.jar HOT 1
- Support Proxy functionality HOT 1
- Volley: [5311] NetworkUtility.logSlowRequests: HTTP response for request=<[ ] HOT 3
- NetworkUtility.logSlowRequests: HTTP response for request=<[ ] https://www.google.com/ 0xd61ac103 NORMAL 1> [lifetime=6472], [size=159525], [rc=200], [retryCount=1]
- Fix nullability issues in Kotlin sample code HOT 4
- Pagination HOT 1
- Getting E/Volley: [19618] NetworkDispatcher.processRequest: Unhandled exception HOT 4
- pls rply me what can i do for this HOT 1
- Potential debug logging even when DEBUG is False HOT 6
- ConcurrentModificationException on cancel HOT 1
- App Crashed on Android version 4.3 java.lang.NoClassDefFoundError: com.android.volley.toolbox.Volley HOT 1
Recommend Projects
-
React
A declarative, efficient, and flexible JavaScript library for building user interfaces.
-
Vue.js
🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
-
Typescript
TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
-
TensorFlow
An Open Source Machine Learning Framework for Everyone
-
Django
The Web framework for perfectionists with deadlines.
-
Laravel
A PHP framework for web artisans
-
D3
Bring data to life with SVG, Canvas and HTML. 📊📈🎉
-
Recommend Topics
-
javascript
JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
-
web
Some thing interesting about web. New door for the world.
-
server
A server is a program made to process requests and deliver data to clients.
-
Machine learning
Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
-
Visualization
Some thing interesting about visualization, use data art
-
Game
Some thing interesting about game, make everyone happy.
Recommend Org
-
Facebook
We are working to build community through open source technology. NB: members must have two-factor auth.
-
Microsoft
Open source projects and samples from Microsoft.
-
Google
Google ❤️ Open Source for everyone.
-
Alibaba
Alibaba Open Source for everyone
-
D3
Data-Driven Documents codes.
-
Tencent
China tencent open source team.
from volley.