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
|
/*
* Copyright (C) 2010 Google Inc.
*
* 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.i18n.addressinput;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpUriRequest;
import org.apache.http.impl.client.BasicResponseHandler;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.params.HttpConnectionParams;
import org.apache.http.params.HttpParams;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
/**
* Android implementation of those parts of the com.google.gwt.jsonp.client.JsonpRequestBuilder
* class that the CacheData class uses.
*/
class JsonpRequestBuilder {
/**
* Re-implementation of the com.google.gwt.user.client.rpc.AsyncCallback interface.
*/
interface AsyncCallback<T> {
public void onFailure(Throwable caught);
public void onSuccess(T result);
}
/**
* @param timeout The expected timeout (ms) for this request.
*/
void setTimeout(int timeout) {
HttpParams params = AsyncHttp.CLIENT.getParams();
HttpConnectionParams.setConnectionTimeout(params, timeout);
HttpConnectionParams.setSoTimeout(params, timeout);
}
/**
* Sends a JSONP request and expects a JsoMap object as a result.
*/
void requestObject(String url, AsyncCallback<JsoMap> callback) {
HttpUriRequest request = new HttpGet(encodeUrl(url));
(new AsyncHttp(request, callback)).start();
}
/**
* Simple implementation of asynchronous HTTP GET.
*/
private static class AsyncHttp extends Thread {
private static final HttpClient CLIENT = new DefaultHttpClient();
private HttpUriRequest request;
private AsyncCallback<JsoMap> callback;
protected AsyncHttp(HttpUriRequest request, AsyncCallback<JsoMap> callback) {
this.request = request;
this.callback = callback;
}
@Override
public void run() {
try {
final String response;
synchronized (CLIENT) {
response = CLIENT.execute(request, new BasicResponseHandler());
}
callback.onSuccess(JsoMap.buildJsoMap(response));
} catch (Exception e) {
callback.onFailure(e);
}
}
}
/**
* A quick hack to transform a string into an RFC 3986 compliant URL.
*
* TODO: Refactor the code to stop passing URLs around as strings, to eliminate the need for
* this hack.
*/
private static String encodeUrl(String url) {
int length = url.length();
StringBuilder tmp = new StringBuilder(length);
try {
for (int i = 0; i < length; i++) {
int j = i;
char c = '\0';
for (; j < length; j++) {
c = url.charAt(j);
if (c == ':' || c == '/') {
break;
}
}
if (j == length) {
tmp.append(URLEncoder.encode(url.substring(i), "UTF-8"));
break;
} else if (j > i) {
tmp.append(URLEncoder.encode(url.substring(i, j), "UTF-8"));
tmp.append(c);
i = j;
} else {
tmp.append(c);
}
}
} catch (UnsupportedEncodingException e) {
throw new RuntimeException(e); // Impossible.
}
return tmp.toString();
}
}
|
