UnicodeBOMInputStream class wraps any
17 | * InputStream and detects the presence of any Unicode BOM (Byte
18 | * Order Mark) at its beginning, as defined by RFC 3629 - UTF-8, a
20 | * transformation format of ISO 10646
21 | *
22 | * 23 | * The Unicode FAQ 24 | * defines 5 types of BOMs: 25 | *
29 | * 00 00 FE FF = UTF-32, big-endian 30 | *31 | * 32 | *
36 | * FF FE 00 00 = UTF-32, little-endian 37 | *38 | * 39 | *
43 | * FE FF = UTF-16, big-endian 44 | *45 | * 46 | *
50 | * FF FE = UTF-16, little-endian 51 | *52 | * 53 | *
57 | * EF BB BF = UTF-8 58 | *59 | * 60 | *
65 | * Use the {@link #getBOM()} method to know whether a BOM has been detected or 66 | * not. 67 | *
68 | *
69 | * Use the {@link #skipBOM()} method to remove the detected BOM from the wrapped
70 | * InputStream object.
71 | *
String representation of this BOM
118 | * value.
119 | */
120 | @Override
121 | public final String toString() {
122 | return description;
123 | }
124 |
125 | /**
126 | * Returns the bytes corresponding to this BOM value.
127 | */
128 | public final byte[] getBytes() {
129 | final int length = bytes.length;
130 | final byte[] result = new byte[length];
131 |
132 | // Make a defensive copy
133 | System.arraycopy(bytes, 0, result, 0, length);
134 |
135 | return result;
136 | }
137 |
138 | private BOM(final byte bom[], final String description) {
139 | assert (bom != null) : "invalid BOM: null is not allowed";
140 | assert (description != null) : "invalid description: null is not allowed";
141 | assert (description.length() != 0) : "invalid description: empty string is not allowed";
142 |
143 | this.bytes = bom;
144 | this.description = description;
145 | }
146 |
147 | final byte bytes[];
148 | private final String description;
149 |
150 | } // BOM
151 |
152 | /**
153 | * Constructs a new UnicodeBOMInputStream that wraps the
154 | * specified InputStream.
155 | *
156 | * @param inputStream
157 | * an InputStream.
158 | *
159 | * @throws NullPointerException
160 | * when inputStream is null.
161 | * @throws IOException
162 | * on reading from the specified InputStream when
163 | * trying to detect the Unicode BOM.
164 | */
165 | public UnicodeBOMInputStream(final InputStream inputStream)
166 | throws NullPointerException,
167 | IOException
168 |
169 | {
170 | if (inputStream == null) {
171 | throw new NullPointerException("invalid input stream: null is not allowed");
172 | }
173 |
174 | in = new PushbackInputStream(inputStream, 4);
175 |
176 | final byte bom[] = new byte[4];
177 | final int read = in.read(bom);
178 |
179 | switch (read) {
180 | case 4:
181 | if ((bom[0] == (byte) 0xFF) && (bom[1] == (byte) 0xFE) && (bom[2] == (byte) 0x00)
182 | && (bom[3] == (byte) 0x00)) {
183 | this.bom = BOM.UTF_32_LE;
184 | break;
185 | } else if ((bom[0] == (byte) 0x00) && (bom[1] == (byte) 0x00)
186 | && (bom[2] == (byte) 0xFE) && (bom[3] == (byte) 0xFF)) {
187 | this.bom = BOM.UTF_32_BE;
188 | break;
189 | }
190 |
191 | case 3:
192 | if ((bom[0] == (byte) 0xEF) && (bom[1] == (byte) 0xBB) && (bom[2] == (byte) 0xBF)) {
193 | this.bom = BOM.UTF_8;
194 | break;
195 | }
196 |
197 | case 2:
198 | if ((bom[0] == (byte) 0xFF) && (bom[1] == (byte) 0xFE)) {
199 | this.bom = BOM.UTF_16_LE;
200 | break;
201 | } else if ((bom[0] == (byte) 0xFE) && (bom[1] == (byte) 0xFF)) {
202 | this.bom = BOM.UTF_16_BE;
203 | break;
204 | }
205 |
206 | default:
207 | this.bom = BOM.NONE;
208 | break;
209 | }
210 |
211 | if (read > 0) {
212 | in.unread(bom, 0, read);
213 | }
214 | }
215 |
216 | /**
217 | * Returns the BOM that was detected in the wrapped
218 | * InputStream object.
219 | *
220 | * @return a BOM value.
221 | */
222 | public final BOM getBOM() {
223 | // BOM type is immutable.
224 | return bom;
225 | }
226 |
227 | /**
228 | * Skips the BOM that was found in the wrapped
229 | * InputStream object.
230 | *
231 | * @return this UnicodeBOMInputStream.
232 | *
233 | * @throws IOException
234 | * when trying to skip the BOM from the wrapped
235 | * InputStream object.
236 | */
237 | public final synchronized UnicodeBOMInputStream skipBOM() throws IOException {
238 | if (!skipped) {
239 | in.skip(bom.bytes.length);
240 | skipped = true;
241 | }
242 | return this;
243 | }
244 |
245 | /**
246 | * {@inheritDoc}
247 | */
248 | @Override
249 | public int read() throws IOException {
250 | return in.read();
251 | }
252 |
253 | /**
254 | * {@inheritDoc}
255 | */
256 | @Override
257 | public int read(final byte b[]) throws IOException, NullPointerException {
258 | return in.read(b, 0, b.length);
259 | }
260 |
261 | /**
262 | * {@inheritDoc}
263 | */
264 | @Override
265 | public int read(final byte b[], final int off, final int len) throws IOException,
266 | NullPointerException {
267 | return in.read(b, off, len);
268 | }
269 |
270 | /**
271 | * {@inheritDoc}
272 | */
273 | @Override
274 | public long skip(final long n) throws IOException {
275 | return in.skip(n);
276 | }
277 |
278 | /**
279 | * {@inheritDoc}
280 | */
281 | @Override
282 | public int available() throws IOException {
283 | return in.available();
284 | }
285 |
286 | /**
287 | * {@inheritDoc}
288 | */
289 | @Override
290 | public void close() throws IOException {
291 | in.close();
292 | }
293 |
294 | /**
295 | * {@inheritDoc}
296 | */
297 | @Override
298 | public synchronized void mark(final int readlimit) {
299 | in.mark(readlimit);
300 | }
301 |
302 | /**
303 | * {@inheritDoc}
304 | */
305 | @Override
306 | public synchronized void reset() throws IOException {
307 | in.reset();
308 | }
309 |
310 | /**
311 | * {@inheritDoc}
312 | */
313 | @Override
314 | public boolean markSupported() {
315 | return in.markSupported();
316 | }
317 |
318 | private final PushbackInputStream in;
319 | private final BOM bom;
320 | private boolean skipped = false;
321 |
322 | } // UnicodeBOMInputStream
--------------------------------------------------------------------------------
/android-rest-lib/src/main/java/com/dg/libs/rest/exceptions/HttpException.java:
--------------------------------------------------------------------------------
1 | package com.dg.libs.rest.exceptions;
2 |
3 | /**
4 | * usually represents a general error for the whole api call, if you need to
5 | * know if the parsing failed check the status of the response and the error
6 | * message ( if status is SC_OK means the api call was successful and there was
7 | * a parsing error).
8 | *
9 | * @author DArkO
10 | */
11 | public class HttpException extends Exception {
12 |
13 | private static final long serialVersionUID = -120498658240098246L;
14 | @SuppressWarnings("unused")
15 | private static final String TAG = HttpException.class.getSimpleName();
16 |
17 | public HttpException() {
18 | super();
19 | }
20 |
21 | public HttpException(final String detailMessage, final Throwable throwable) {
22 | super(detailMessage, throwable);
23 | }
24 |
25 | public HttpException(final String detailMessage) {
26 | super(detailMessage);
27 | }
28 |
29 | public HttpException(final Throwable throwable) {
30 | super(throwable);
31 | }
32 |
33 | }
34 |
--------------------------------------------------------------------------------
/android-rest-lib/src/main/java/com/dg/libs/rest/exceptions/ParseException.java:
--------------------------------------------------------------------------------
1 | package com.dg.libs.rest.exceptions;
2 |
3 | public class ParseException extends HttpException {
4 |
5 | private static final long serialVersionUID = -7964127989566422126L;
6 | @SuppressWarnings("unused")
7 | private static final String TAG = ParseException.class.getSimpleName();
8 |
9 | public ParseException(final String s) {
10 | super(s);
11 | }
12 |
13 | public ParseException(final String detailMessage, final Throwable throwable) {
14 | super(detailMessage, throwable);
15 | }
16 |
17 | public ParseException(final Throwable throwable) {
18 | super(throwable);
19 | }
20 |
21 | }
22 |
--------------------------------------------------------------------------------
/android-rest-lib/src/main/java/com/dg/libs/rest/handlers/BackgroundThreadResponseHandler.java:
--------------------------------------------------------------------------------
1 | package com.dg.libs.rest.handlers;
2 |
3 | import com.dg.libs.rest.callbacks.HttpCallback;
4 | import com.dg.libs.rest.domain.ResponseStatus;
5 |
6 | public class BackgroundThreadResponseHandler
26 | * Dont forget to set the password on first init
27 | *
28 | * @return
29 | */
30 | public static synchronized TokenAuthenticationProvider getInstance() {
31 | if (account == null) {
32 | throw new RuntimeException("Initialize the Provider first");
33 | }
34 | return account;
35 | }
36 |
37 | public static synchronized void init(Context context) {
38 | if (account == null) {
39 | account = new TokenAuthenticationProvider(context);
40 | }
41 | }
42 |
43 | private TokenAuthenticationProvider(final Context context) {
44 | this.context = context.getApplicationContext();
45 | initializeToken();
46 | }
47 |
48 | @Override
49 | public void authenticateRequest(RestClientRequest client) {
50 | if (TextUtils.isEmpty(token)) {
51 | return;
52 | }
53 | client.addHeader("Authorization", "OAuth " + token);
54 | }
55 |
56 | public String getToken() {
57 | return token;
58 | }
59 |
60 | public void setToken(String token) {
61 | this.token = token;
62 | saveApiKey(token);
63 | }
64 |
65 | public boolean isTokenValid() {
66 | return !TextUtils.isEmpty(token);
67 | }
68 |
69 | public boolean clearAuth() {
70 | Editor editor = PreferenceManager.getDefaultSharedPreferences(context).edit();
71 | editor.remove(TOKEN_KEY);
72 | boolean commit = editor.commit();
73 | return commit;
74 | }
75 |
76 | /**
77 | * Use as an alternative for saving the token to accounts (Note that using the
78 | * account manager is a preferred and safer method)
79 | *
80 | * @param apiKey
81 | * the token aqured from chute auth
82 | * @return if the save was successful
83 | */
84 | private boolean saveApiKey(final String apiKey) {
85 | Editor editor = PreferenceManager.getDefaultSharedPreferences(context).edit();
86 | editor.putString(TOKEN_KEY, apiKey);
87 | boolean commit = editor.commit();
88 | return commit;
89 | }
90 |
91 | private String restoreApiKey() {
92 | SharedPreferences savedSession = PreferenceManager
93 | .getDefaultSharedPreferences(context);
94 | return savedSession.getString(TOKEN_KEY, "");
95 | }
96 |
97 | private void initializeToken() {
98 | String apiKey = restoreApiKey();
99 | if (!TextUtils.isEmpty(apiKey)) {
100 | this.setToken(apiKey);
101 | return;
102 | }
103 | // Set a manual token for testing
104 | // this.setPassword("46e580a90085912ed11c565084f1f2465f28630bd58fa80cc98432f3078fc5ac");
105 | }
106 | }
107 |
--------------------------------------------------------------------------------
/rest-client-demo/src/main/java/com/dg/examples/restclientdemo/communication/RestConstants.java:
--------------------------------------------------------------------------------
1 | package com.dg.examples.restclientdemo.communication;
2 |
3 |
4 | public class RestConstants {
5 |
6 | public static final String TAG = RestConstants.class.getSimpleName();
7 |
8 | public static final String BASE_URL = "https://ajax.googleapis.com";
9 | public static final String LOG_SERVICE_URL = "http://log-requests.herokuapp.com/";
10 | public static final String HTTP_BIN_URL = "http://httpbin.org/";
11 |
12 |
13 | public static final String GOOGLE_BLOGS = BASE_URL + "/ajax/services/feed/find";
14 | }
15 |
16 |
--------------------------------------------------------------------------------
/rest-client-demo/src/main/java/com/dg/examples/restclientdemo/communication/parsers/BlogsGoogleParser.java:
--------------------------------------------------------------------------------
1 | package com.dg.examples.restclientdemo.communication.parsers;
2 |
3 | import com.dg.examples.restclientdemo.domain.ResponseModel;
4 | import com.dg.libs.rest.parsers.BaseJacksonMapperResponseParser;
5 |
6 | import java.io.InputStream;
7 |
8 |
9 | public class BlogsGoogleParser extends BaseJacksonMapperResponseParser