1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
|
package com.mapbox.mapboxsdk.module.http;
import android.os.Build;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.annotation.VisibleForTesting;
import android.text.TextUtils;
import android.util.Log;
import com.mapbox.mapboxsdk.BuildConfig;
import com.mapbox.mapboxsdk.constants.MapboxConstants;
import com.mapbox.mapboxsdk.http.HttpIdentifier;
import com.mapbox.mapboxsdk.http.HttpLogger;
import com.mapbox.mapboxsdk.http.HttpRequest;
import com.mapbox.mapboxsdk.http.HttpRequestUrl;
import com.mapbox.mapboxsdk.http.HttpResponder;
import okhttp3.Call;
import okhttp3.Callback;
import okhttp3.Dispatcher;
import okhttp3.HttpUrl;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.ResponseBody;
import javax.net.ssl.SSLException;
import java.io.IOException;
import java.io.InterruptedIOException;
import java.net.NoRouteToHostException;
import java.net.ProtocolException;
import java.net.SocketException;
import java.net.UnknownHostException;
import static com.mapbox.mapboxsdk.module.http.HttpRequestUtil.toHumanReadableAscii;
public class HttpRequestImpl implements HttpRequest {
private static final String userAgentString = toHumanReadableAscii(
String.format("%s %s (%s) Android/%s (%s)",
HttpIdentifier.getIdentifier(),
BuildConfig.MAPBOX_VERSION_STRING,
BuildConfig.GIT_REVISION_SHORT,
Build.VERSION.SDK_INT,
Build.CPU_ABI)
);
@VisibleForTesting
static final OkHttpClient DEFAULT_CLIENT = new OkHttpClient.Builder().dispatcher(getDispatcher()).build();
@VisibleForTesting
static OkHttpClient client = DEFAULT_CLIENT;
private Call call;
@Override
public void executeRequest(HttpResponder httpRequest, long nativePtr, @NonNull String resourceUrl,
@NonNull String etag, @NonNull String modified, boolean offlineUsage) {
OkHttpCallback callback = new OkHttpCallback(httpRequest);
try {
HttpUrl httpUrl = HttpUrl.parse(resourceUrl);
if (httpUrl == null) {
HttpLogger.log(Log.ERROR, String.format("[HTTP] Unable to parse resourceUrl %s", resourceUrl));
return;
}
final String host = httpUrl.host().toLowerCase(MapboxConstants.MAPBOX_LOCALE);
resourceUrl = HttpRequestUrl.buildResourceUrl(host, resourceUrl, httpUrl.querySize(), offlineUsage);
final Request.Builder builder = new Request.Builder()
.url(resourceUrl)
.tag(resourceUrl.toLowerCase(MapboxConstants.MAPBOX_LOCALE))
.addHeader("User-Agent", userAgentString);
if (etag.length() > 0) {
builder.addHeader("If-None-Match", etag);
} else if (modified.length() > 0) {
builder.addHeader("If-Modified-Since", modified);
}
final Request request = builder.build();
call = client.newCall(request);
call.enqueue(callback);
} catch (Exception exception) {
callback.handleFailure(call, exception);
}
}
@Override
public void cancelRequest() {
// call can be null if the constructor gets aborted (e.g, under a NoRouteToHostException).
if (call != null) {
call.cancel();
}
}
public static void enablePrintRequestUrlOnFailure(boolean enabled) {
HttpLogger.logRequestUrl = enabled;
}
public static void enableLog(boolean enabled) {
HttpLogger.logEnabled = enabled;
}
public static void setOkHttpClient(@Nullable OkHttpClient okHttpClient) {
if (okHttpClient != null) {
HttpRequestImpl.client = okHttpClient;
} else {
HttpRequestImpl.client = DEFAULT_CLIENT;
}
}
private static class OkHttpCallback implements Callback {
private HttpResponder httpRequest;
OkHttpCallback(HttpResponder httpRequest) {
this.httpRequest = httpRequest;
}
@Override
public void onFailure(@NonNull Call call, @NonNull IOException e) {
handleFailure(call, e);
}
@Override
public void onResponse(@NonNull Call call, @NonNull Response response) {
if (response.isSuccessful()) {
HttpLogger.log(Log.VERBOSE, String.format("[HTTP] Request was successful (code = %s).", response.code()));
} else {
// We don't want to call this unsuccessful because a 304 isn't really an error
String message = !TextUtils.isEmpty(response.message()) ? response.message() : "No additional information";
HttpLogger.log(Log.DEBUG, String.format("[HTTP] Request with response = %s: %s", response.code(), message));
}
ResponseBody responseBody = response.body();
if (responseBody == null) {
HttpLogger.log(Log.ERROR, "[HTTP] Received empty response body");
return;
}
byte[] body;
try {
body = responseBody.bytes();
} catch (IOException ioException) {
onFailure(call, ioException);
// throw ioException;
return;
} finally {
response.close();
}
httpRequest.onResponse(response.code(),
response.header("ETag"),
response.header("Last-Modified"),
response.header("Cache-Control"),
response.header("Expires"),
response.header("Retry-After"),
response.header("x-rate-limit-reset"),
body);
}
private void handleFailure(@Nullable Call call, Exception e) {
String errorMessage = e.getMessage() != null ? e.getMessage() : "Error processing the request";
int type = getFailureType(e);
if (HttpLogger.logEnabled && call != null && call.request() != null) {
String requestUrl = call.request().url().toString();
HttpLogger.logFailure(type, errorMessage, requestUrl);
}
httpRequest.handleFailure(type, errorMessage);
}
private int getFailureType(Exception e) {
if ((e instanceof NoRouteToHostException) || (e instanceof UnknownHostException) || (e instanceof SocketException)
|| (e instanceof ProtocolException) || (e instanceof SSLException)) {
return CONNECTION_ERROR;
} else if ((e instanceof InterruptedIOException)) {
return TEMPORARY_ERROR;
}
return PERMANENT_ERROR;
}
}
@NonNull
private static Dispatcher getDispatcher() {
Dispatcher dispatcher = new Dispatcher();
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
// Matches core limit set on
// https://github.com/mapbox/mapbox-gl-native/blob/master/platform/android/src/http_file_source.cpp#L192
dispatcher.setMaxRequestsPerHost(20);
} else {
// Limiting concurrent request on Android 4.4, to limit impact of SSL handshake platform library crash
// https://github.com/mapbox/mapbox-gl-native/issues/14910
dispatcher.setMaxRequestsPerHost(10);
}
return dispatcher;
}
}
|
