398 
+        switch (type) {
399 
+        case Type.Command:
400 
+        case Type.Data:
401 
+            return operationToString(code);
402 
+        case Type.Response:
403 
+            return responseToString(code);
404 
+        case Type.Event:
405 
+            return eventToString(code);
406 
+        default:
407 
+            return String.format("0x%04x", code);
408 
+        }
409 
+    }
410 
+
411 
+    /**
412 
+     * Returns the name of the constant that has the specified {@code constant}
413 
+     * in the specified {@code clazz}.
414 
+     */
415 
+    public static String constantToString(Class<?> clazz, int constant) {
416 
+        String hexString = String.format("0x%04x", constant);
417 
+        for (Field f : clazz.getDeclaredFields()) {
418 
+            if (f.getType() != int.class || !Modifier.isStatic(f.getModifiers()) || !Modifier.isFinal(f.getModifiers())) {
419 
+                continue;
420 
+            }
421 
+            try {
422 
+                if (f.getInt(null) == constant) {
423 
+                    return f.getName() + "(" + hexString + ")";
424 
+                }
425 
+            } catch (Throwable e) {
426 
+                // nop
427 
+                e.printStackTrace();
428 
+            }
429 
+        }
430 
+        return hexString;
431 
+    }
432 
+
433 
+    /**
434 
+     * Reads {@code DeviceInfo.toString} from input and rewrites codes to
435 
+     * names(codes).
436 
+     *
437 
+     * @throws IOException
438 
+     */
439 
+    public static void main(String[] args) throws IOException {
440 
+        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
441 
+        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(System.out));
442 
+        String line = null;
443 
+        int state = 0;
444 
+
445 
+        while ((line = reader.readLine()) != null) {
446 
+            if ("OperationsSupported:".equals(line)) {
447 
+                state = 1;
448 
+                writer.write(line);
449 
+            } else if ("EventsSupported:".equals(line)) {
450 
+                state = 2;
451 
+                writer.write(line);
452 
+            } else if ("DevicePropertiesSupported:".equals(line)) {
453 
+                state = 3;
454 
+                writer.write(line);
455 
+            } else if ("CaptureFormats:".equals(line)) {
456 
+                state = 4;
457 
+                writer.write(line);
458 
+            } else if ("ImageFormats:".equals(line)) {
459 
+                state = 5;
460 
+                writer.write(line);
461 
+            } else {
462 
+                if (line.startsWith("    0x") || line.matches("    .+\\)$")) {
463 
+                    if (line.startsWith("    0x")) {
464 
+                        line = line.trim().substring(2);
465 
+                    } else {
466 
+                        int bracket = line.indexOf('(');
467 
+                        line = line.substring(bracket + 3, line.length() - 1);
468 
+                    }
469 
+                    int number = Integer.parseInt(line, 16);
470 
+                    String value = null;
471 
+                    switch (state) {
472 
+                    case 1:
473 
+                        value = operationToString(number);
474 
+                        break;
475 
+                    case 2:
476 
+                        value = eventToString(number);
477 
+                        break;
478 
+                    case 3:
479 
+                        value = propertyToString(number);
480 
+                        break;
481 
+                    case 4:
482 
+                    case 5:
483 
+                        value = objectFormatToString(number);
484 
+                        break;
485 
+                    }
486 
+                    writer.write(String.format("    %s", value));
487 
+                } else {
488 
+                    writer.write(line);
489 
+                }
490 
+            }
491 
+             writer.newLine();
492 
+        }
493 
+
494 
+        writer.flush();
495 
+    }
496 
+}

+ 803 - 0
app/src/main/java/com/remoteyourcam/usb/ptp/PtpPropertyHelper.java
Преглед на файла 

@@ -0,0 +1,803 @@
1 
+/**
2 
+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech
3 
+ *
4 
+ * Licensed under the Apache License, Version 2.0 (the "License");
5 
+ * you may not use this file except in compliance with the License.
6 
+ * You may obtain a copy of the License at
7 
+ *
8 
+ *     http://www.apache.org/licenses/LICENSE-2.0
9 
+ *
10 
+ * Unless required by applicable law or agreed to in writing, software
11 
+ * distributed under the License is distributed on an "AS IS" BASIS,
12 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 
+ * See the License for the specific language governing permissions and
14 
+ * limitations under the License.
15 
+ */
16 
+package com.remoteyourcam.usb.ptp;
17 
+
18 
+import com.remoteyourcam.usb.ptp.PtpConstants.Product;
19 
+import com.remoteyourcam.usb.ptp.PtpConstants.Property;
20 
+
21 
+import java.util.HashMap;
22 
+import java.util.Map;
23 
+
24 
+/**
25 
+ * Helper to convert property values to their string representations.
26 
+ */
27 
+public class PtpPropertyHelper {
28 
+
29 
+    public static final int EOS_SHUTTER_SPEED_BULB = 0x0c;
30 
+
31 
+    private static final Map<Integer, String> eosShutterSpeedMap = new HashMap<Integer, String>();
32 
+    private static final Map<Integer, String> eosApertureValueMap = new HashMap<Integer, String>();
33 
+    private static final Map<Integer, String> eosIsoSpeedMap = new HashMap<Integer, String>();
34 
+    private static final Map<Integer, String> eosWhitebalanceMap = new HashMap<Integer, String>();
35 
+    private static final Map<Integer, Integer> eosWhitebalanceIconsMap = new HashMap<Integer, Integer>();
36 
+    private static final Map<Integer, String> eosShootingModeMap = new HashMap<Integer, String>();
37 
+    private static final Map<Integer, Integer> eosShootingModeIconsMap = new HashMap<Integer, Integer>();
38 
+    private static final Map<Integer, Integer> eosMeteringModeIconsMap = new HashMap<Integer, Integer>();
39 
+    private static final Map<Integer, String> eosDriveModeMap = new HashMap<Integer, String>();
40 
+    private static final Map<Integer, Integer> eosDriveModeIconsMap = new HashMap<Integer, Integer>();
41 
+    private static final Map<Integer, String> eosFocusModeMap = new HashMap<Integer, String>();
42 
+    private static final Map<Integer, String> eosPictureStyleMap = new HashMap<Integer, String>();
43 
+
44 
+    private static final Map<Integer, String> nikonWhitebalanceMap = new HashMap<Integer, String>();
45 
+    private static final Map<Integer, Integer> nikonWhitebalanceIconsMap = new HashMap<Integer, Integer>();
46 
+    private static final Map<Integer, String> nikonExposureIndexMap = new HashMap<Integer, String>();
47 
+    private static final Map<Integer, Integer> nikonExposureProgramMap = new HashMap<Integer, Integer>();
48 
+    private static final Map<Integer, String> nikonWbColorTempD300SMap = new HashMap<Integer, String>();
49 
+    private static final Map<Integer, String> nikonWbColorTempD200Map = new HashMap<Integer, String>();
50 
+    private static final Map<Integer, String> nikonFocusModeMap = new HashMap<Integer, String>();
51 
+    private static final Map<Integer, String> nikonActivePicCtrlItemMap = new HashMap<Integer, String>();
52 
+    private static final Map<Integer, Integer> nikonMeteringModeMap = new HashMap<Integer, Integer>();
53 
+    private static final Map<Integer, String> nikonFocusMeteringModeMap = new HashMap<Integer, String>();
54 
+    private static final Map<Integer, Integer> nikonFocusMeteringModeIconsMap = new HashMap<Integer, Integer>();
55 
+
56 
+    public static String mapToString(int productId, int property, int value) {
57 
+        switch (property) {
58 
+        case Property.EosShutterSpeed: {
59 
+            String s = eosShutterSpeedMap.get(value);
60 
+            return s != null ? s : "?";
61 
+        }
62 
+        case Property.EosApertureValue: {
63 
+            String s = eosApertureValueMap.get(value);
64 
+            return "f " + (s != null ? s : '?');
65 
+        }
66 
+        case Property.EosIsoSpeed:
67 
+            return eosIsoSpeedMap.get(value);
68 
+        case Property.EosWhitebalance:
69 
+            return eosWhitebalanceMap.get(value);
70 
+        case Property.EosShootingMode:
71 
+            return eosShootingModeMap.get(value);
72 
+        case Property.EosDriveMode:
73 
+            return eosDriveModeMap.get(value);
74 
+        case Property.WhiteBalance:
75 
+            return nikonWhitebalanceMap.get(value);
76 
+        case Property.FNumber: {
77 
+            int major = value / 100;
78 
+            int minor = value % 100;
79 
+            if (minor == 0) {
80 
+                return "f " + major;
81 
+            } else if (minor % 10 == 0) {
82 
+                return "f " + major + '.' + minor / 10;
83 
+            } else {
84 
+                return "f " + major + '.' + minor;
85 
+            }
86 
+        }
87 
+        case Property.ExposureTime: {
88 
+            if (value == 0xFFFFFFFF) {
89 
+                return "Bulb";
90 
+            }
91 
+            int seconds = value / 10000;
92 
+            int rest = value % 10000;
93 
+            StringBuilder b = new StringBuilder();
94 
+            if (seconds > 0) {
95 
+                b.append(seconds).append("\"");
96 
+            }
97 
+            if (rest > 0) {
98 
+                b.append("1/").append(Math.round(1.0 / (rest * 0.0001)));
99 
+            }
100 
+            return b.toString();
101 
+        }
102 
+        case Property.ExposureIndex:
103 
+            return getNikonExposureIndex(productId, value);
104 
+        case Property.EosColorTemperature:
105 
+            return Integer.toString(value) + "K";
106 
+        case Property.NikonWbColorTemp:
107 
+            return getNikonWbColorTemp(productId, value);
108 
+        case Property.EosAfMode:
109 
+            return eosFocusModeMap.get(value);
110 
+        case Property.FocusMode:
111 
+            return nikonFocusModeMap.get(value);
112 
+        case Property.NikonShutterSpeed: {
113 
+            int numerator = value >> 16 & 0xffff;
114 
+            int denominator = value & 0xffff;
115 
+            if (denominator == 1) {
116 
+                return "" + numerator + "\"";
117 
+            } else if (numerator == 1) {
118 
+                return "1/" + denominator;
119 
+            } else if (value == 0xFFFFFFFF) {
120 
+                return "Bulb";
121 
+            } else if (value == 0xFFFFFFFE) {
122 
+                return "Flash";
123 
+            } else if (numerator > denominator) {
124 
+                return String.format("%.1f\"", numerator / (double) denominator);
125 
+            }
126 
+            return "" + numerator + "/" + denominator;
127 
+        }
128 
+        case Property.NikonActivePicCtrlItem:
129 
+            return nikonActivePicCtrlItemMap.get(value);
130 
+        case Property.FocusMeteringMode:
131 
+            return nikonFocusMeteringModeMap.get(value);
132 
+        case Property.NikonExposureIndicateStatus:
133 
+            return "" + value / 6 + "." + Math.abs(value) % 6 + " EV";
134 
+        case Property.EosPictureStyle:
135 
+            return eosPictureStyleMap.get(value);
136 
+        case Property.EosExposureCompensation: {
137 
+            int v;
138 
+            char ch;
139 
+            if (value > 0x80) {
140 
+                v = 0x100 - value;
141 
+                ch = '-';
142 
+            } else {
143 
+                v = value;
144 
+                ch = '+';
145 
+            }
146 
+            if (v == 0) {
147 
+                return " 0";
148 
+            }
149 
+            int first = v / 8;
150 
+            int second = v % 8;
151 
+            String dec = second == 3 ? "1/3" : second == 4 ? "1/2" : second == 5 ? "2/3" : "";
152 
+            if (first > 0) {
153 
+                return String.format("%c%d %s", ch, first, dec);
154 
+            } else {
155 
+                return String.format("%c%s", ch, dec);
156 
+            }
157 
+        }
158 
+        case Property.ExposureBiasCompensation: {
159 
+            int dec = Math.round(Math.abs(value) / 100.0f);
160 
+            int upper = dec / 10;
161 
+            int lower = dec % 10;
162 
+            char sign = value >= 0 ? '+' : '-';
163 
+            return String.format("%c%d.%d", sign, upper, lower);
164 
+        }
165 
+        default:
166 
+            return "?";
167 
+        }
168 
+    }
169 
+
170 
+    private static String getNikonExposureIndex(int productId, int value) {
171 
+        switch (productId) {
172 
+        case Product.NikonD300:
173 
+        case Product.NikonD300S:
174 
+        case Product.NikonD5000:
175 
+            if (value == 0x0064) {
176 
+                return "LO-1";
177 
+            } else if (value == 0x007D) {
178 
+                return "LO-0.7";
179 
+            } else if (value == 0x00A0) {
180 
+                return "LO-0.3";
181 
+            } else if (value == 0x0FA0) {
182 
+                return "Hi-0.3";
183 
+            } else if (value == 0x1194) {
184 
+                return "Hi-0.5";
185 
+            } else if (value == 0x1388) {
186 
+                return "Hi-0.7";
187 
+            } else if (value == 0x1900) {
188 
+                return "Hi-1";
189 
+            }
190 
+            break;
191 
+        case Product.NikonD7000:
192 
+            if (value == 0x1F40) {
193 
+                return "Hi-0.3";
194 
+            } else if (value == 0x2328) {
195 
+                return "Hi-0.5";
196 
+            } else if (value == 0x2710) {
197 
+                return "Hi-0.7";
198 
+            } else if (value == 0x3200) {
199 
+                return "Hi-1";
200 
+            } else if (value == 0x6400) {
201 
+                return "Hi-2";
202 
+            }
203 
+            break;
204 
+        case Product.NikonD80:
205 
+        case Product.NikonD200:
206 
+        case Product.NikonD40:
207 
+            if (value == 0x07D0) {
208 
+                return "Hi-0.3";
209 
+            } else if (value == 0x09C4) {
210 
+                return "Hi-0.7";
211 
+            } else if (value == 0x0C80) {
212 
+                return "Hi-1";
213 
+            } else if (value == 0x0898) { // D200 only
214 
+                return "Hi-0.5";
215 
+            }
216 
+            break;
217 
+        case Product.NikonD3:
218 
+            if (value == 0x0064) {
219 
+                return "LO-1";
220 
+            } else if (value == 0x007D) {
221 
+                return "LO-0.7";
222 
+            } else if (value == 0x008C) {
223 
+                return "LO-0.5";
224 
+            } else if (value == 0x00A0) {
225 
+                return "LO-0.3";
226 
+            } else if (value == 0x2080) {
227 
+                return "Hi-0.3";
228 
+            } else if (value == 0x2300) {
229 
+                return "Hi-0.5";
230 
+            } else if (value == 0x2800) {
231 
+                return "Hi-0.7";
232 
+            } else if (value == 0x3200) {
233 
+                return "Hi-1";
234 
+            } else if (value == 0x6400) {
235 
+                return "Hi-2";
236 
+            }
237 
+            break;
238 
+        case Product.NikonD3X:
239 
+            if (value == 0x0032) {
240 
+                return "LO-1";
241 
+            } else if (value == 0x003E) {
242 
+                return "LO-0.7";
243 
+            } else if (value == 0x0046) {
244 
+                return "LO-0.5";
245 
+            } else if (value == 0x0050) {
246 
+                return "LO-0.3";
247 
+            } else if (value == 0x07D0) {
248 
+                return "Hi-0.3";
249 
+            } else if (value == 0x08C0) {
250 
+                return "Hi-0.5";
251 
+            } else if (value == 0x0A00) {
252 
+                return "Hi-0.7";
253 
+            } else if (value == 0x0C80) {
254 
+                return "Hi-1";
255 
+            } else if (value == 0x1900) {
256 
+                return "Hi-2";
257 
+            }
258 
+            break;
259 
+        case Product.NikonD3S:
260 
+            if (value == 0x0064) {
261 
+                return "LO-1";
262 
+            } else if (value == 0x007D) {
263 
+                return "LO-0.7";
264 
+            } else if (value == 0x008C) {
265 
+                return "LO-0.5";
266 
+            } else if (value == 0x00A0) {
267 
+                return "LO-0.3";
268 
+            } else if (value == 0x3840) {
269 
+                return "Hi-0.3";
270 
+            } else if (value == 0x4650) {
271 
+                return "Hi-0.5";
272 
+            } else if (value == 0x4E20) {
273 
+                return "Hi-0.7";
274 
+            } else if (value == 0x6400) {
275 
+                return "Hi-1";
276 
+            } else if (value == 0xC800) {
277 
+                return "Hi-2";
278 
+            }
279 
+            break;
280 
+        }
281 
+        return nikonExposureIndexMap.get(value);
282 
+    }
283 
+
284 
+    private static String getNikonWbColorTemp(int productId, int value) {
285 
+        switch (productId) {
286 
+        case Product.NikonD300S:
287 
+        case Product.NikonD3:
288 
+        case Product.NikonD3S:
289 
+        case Product.NikonD3X:
290 
+        case Product.NikonD300:
291 
+        case Product.NikonD700:
292 
+        case Product.NikonD7000:
293 
+        case Product.NikonD90:
294 
+            return nikonWbColorTempD300SMap.get(value);
295 
+        case Product.NikonD200:
296 
+        case Product.NikonD80:
297 
+            return nikonWbColorTempD200Map.get(value);
298 
+            //case Product.NikonD60:
299 
+            //case Product.NikonD40:
300 
+            //case Product.NikonD5000:
301 
+            //    return null;
302 
+        }
303 
+        return null;
304 
+    }
305 
+
306 
+    public static Integer mapToDrawable(int property, int value) {
307 
+//        switch (property) {
308 
+//        case Property.EosWhitebalance: {
309 
+//            Integer resId = eosWhitebalanceIconsMap.get(value);
310 
+//            return resId != null ? resId : R.drawable.whitebalance_unknown;
311 
+//        }
312 
+//        case Property.EosShootingMode: {
313 
+//            Integer resId = eosShootingModeIconsMap.get(value);
314 
+//            return resId != null ? resId : R.drawable.shootingmode_unknown;
315 
+//        }
316 
+//        case Property.EosMeteringMode: {
317 
+//            Integer resId = eosMeteringModeIconsMap.get(value);
318 
+//            return resId != null ? resId : R.drawable.whitebalance_unknown; //TODO own unknown image
319 
+//        }
320 
+//        case Property.EosDriveMode: {
321 
+//            Integer resId = eosDriveModeIconsMap.get(value);
322 
+//            return resId != null ? resId : R.drawable.whitebalance_unknown; //TODO own unknown image
323 
+//        }
324 
+//        case Property.WhiteBalance: {
325 
+//            Integer resId = nikonWhitebalanceIconsMap.get(value);
326 
+//            return resId != null ? resId : R.drawable.whitebalance_unknown;
327 
+//        }
328 
+//        case Property.ExposureProgramMode: {
329 
+//            Integer resId = nikonExposureProgramMap.get(value);
330 
+//            return resId != null ? resId : R.drawable.whitebalance_unknown;
331 
+//        }
332 
+//        case Property.ExposureMeteringMode: {
333 
+//            Integer resId = nikonMeteringModeMap.get(value);
334 
+//            return resId != null ? resId : R.drawable.whitebalance_unknown;
335 
+//        }
336 
+//        case Property.FocusMeteringMode: {
337 
+//            Integer resId = nikonFocusMeteringModeIconsMap.get(value);
338 
+//            return resId != null ? resId : R.drawable.whitebalance_unknown;
339 
+//        }
340 
+//        default:
341 
+//            return null;
342 
+//        }
343 
+        return null;
344 
+    }
345 
+
346 
+    public static String getBiggestValue(int property) {
347 
+        switch (property) {
348 
+        case Property.EosShutterSpeed:
349 
+            return "1/8000";
350 
+        case Property.EosApertureValue:
351 
+            return "f 9.5";
352 
+        case Property.EosIsoSpeed:
353 
+            return "102400";
354 
+        case Property.FNumber:
355 
+            return "33.3"; // ?
356 
+        case Property.ExposureTime:
357 
+            return "1/10000";
358 
+        case Property.ExposureIndex:
359 
+            return "LO-0.3";
360 
+        default:
361 
+            return "";
362 
+        }
363 
+    }
364 
+
365 
+    static {
366 
+        eosShutterSpeedMap.put(0x0c, "Bulb");
367 
+        eosShutterSpeedMap.put(0x10, "30\"");
368 
+        eosShutterSpeedMap.put(0x13, "25\"");
369 
+        eosShutterSpeedMap.put(0x14, "20\"");
370 
+        eosShutterSpeedMap.put(0x15, "20\""); // (1/3)");
371 
+        eosShutterSpeedMap.put(0x18, "15\"");
372 
+        eosShutterSpeedMap.put(0x1B, "13\"");
373 
+        eosShutterSpeedMap.put(0x1C, "10\"");
374 
+        eosShutterSpeedMap.put(0x1D, "10\""); // (1/3)");
375 
+        eosShutterSpeedMap.put(0x20, "8\"");
376 
+        eosShutterSpeedMap.put(0x23, "6\""); // (1/3)");
377 
+        eosShutterSpeedMap.put(0x24, "6\"");
378 
+        eosShutterSpeedMap.put(0x25, "5\"");
379 
+        eosShutterSpeedMap.put(0x28, "4\"");
380 
+        eosShutterSpeedMap.put(0x2B, "3\"2");
381 
+        eosShutterSpeedMap.put(0x2C, "3\"");
382 
+        eosShutterSpeedMap.put(0x2D, "2\"5");
383 
+        eosShutterSpeedMap.put(0x25, "5\"");
384 
+        eosShutterSpeedMap.put(0x28, "4\"");
385 
+        eosShutterSpeedMap.put(0x2B, "3\"2");
386 
+        eosShutterSpeedMap.put(0x2C, "3\"");
387 
+        eosShutterSpeedMap.put(0x2D, "2\"5");
388 
+        eosShutterSpeedMap.put(0x30, "2\"");
389 
+        eosShutterSpeedMap.put(0x33, "1\"6");
390 
+        eosShutterSpeedMap.put(0x34, "1\"5");
391 
+        eosShutterSpeedMap.put(0x35, "1\"3");
392 
+        eosShutterSpeedMap.put(0x38, "1");
393 
+        eosShutterSpeedMap.put(0x3B, "0\"8");
394 
+        eosShutterSpeedMap.put(0x3C, "0\"7");
395 
+        eosShutterSpeedMap.put(0x3D, "0\"6");
396 
+        eosShutterSpeedMap.put(0x40, "0\"5");
397 
+        eosShutterSpeedMap.put(0x43, "0\"4");
398 
+        eosShutterSpeedMap.put(0x44, "0\"3");
399 
+        eosShutterSpeedMap.put(0x45, "0\"3"); // (1/3)");
400 
+        eosShutterSpeedMap.put(0x48, "1/4");
401 
+        eosShutterSpeedMap.put(0x4B, "1/5");
402 
+        eosShutterSpeedMap.put(0x4C, "1/6");
403 
+        eosShutterSpeedMap.put(0x4D, "1/6"); // (1/3)");
404 
+        eosShutterSpeedMap.put(0x50, "1/8");
405 
+        eosShutterSpeedMap.put(0x53, "1/10"); // (1/3)");
406 
+        eosShutterSpeedMap.put(0x54, "1/10");
407 
+        eosShutterSpeedMap.put(0x55, "1/13");
408 
+        eosShutterSpeedMap.put(0x58, "1/15");
409 
+        eosShutterSpeedMap.put(0x5B, "1/20"); // (1/3)");
410 
+        eosShutterSpeedMap.put(0x5C, "1/20");
411 
+        eosShutterSpeedMap.put(0x5D, "1/25");
412 
+        eosShutterSpeedMap.put(0x60, "1/30");
413 
+        eosShutterSpeedMap.put(0x63, "1/40");
414 
+        eosShutterSpeedMap.put(0x64, "1/45");
415 
+        eosShutterSpeedMap.put(0x65, "1/50");
416 
+        eosShutterSpeedMap.put(0x68, "1/60");
417 
+        eosShutterSpeedMap.put(0x6B, "1/80");
418 
+        eosShutterSpeedMap.put(0x6C, "1/90");
419 
+        eosShutterSpeedMap.put(0x6D, "1/100");
420 
+        eosShutterSpeedMap.put(0x70, "1/125");
421 
+        eosShutterSpeedMap.put(0x73, "1/160");
422 
+        eosShutterSpeedMap.put(0x74, "1/180");
423 
+        eosShutterSpeedMap.put(0x75, "1/200");
424 
+        eosShutterSpeedMap.put(0x78, "1/250");
425 
+        eosShutterSpeedMap.put(0x7B, "1/320");
426 
+        eosShutterSpeedMap.put(0x7C, "1/350");
427 
+        eosShutterSpeedMap.put(0x7D, "1/400");
428 
+        eosShutterSpeedMap.put(0x80, "1/500");
429 
+        eosShutterSpeedMap.put(0x83, "1/640");
430 
+        eosShutterSpeedMap.put(0x84, "1/750");
431 
+        eosShutterSpeedMap.put(0x85, "1/800");
432 
+        eosShutterSpeedMap.put(0x88, "1/1000");
433 
+        eosShutterSpeedMap.put(0x8B, "1/1250");
434 
+        eosShutterSpeedMap.put(0x8C, "1/1500");
435 
+        eosShutterSpeedMap.put(0x8D, "1/1600");
436 
+        eosShutterSpeedMap.put(0x90, "1/2000");
437 
+        eosShutterSpeedMap.put(0x93, "1/2500");
438 
+        eosShutterSpeedMap.put(0x94, "1/3000");
439 
+        eosShutterSpeedMap.put(0x95, "1/3200");
440 
+        eosShutterSpeedMap.put(0x98, "1/4000");
441 
+        eosShutterSpeedMap.put(0x9B, "1/5000");
442 
+        eosShutterSpeedMap.put(0x9C, "1/6000");
443 
+        eosShutterSpeedMap.put(0x9D, "1/6400");
444 
+        eosShutterSpeedMap.put(0xA0, "1/8000");
445 
+
446 
+        eosApertureValueMap.put(0x08, "1");
447 
+        eosApertureValueMap.put(0x0B, "1.1");
448 
+        eosApertureValueMap.put(0x0C, "1.2");
449 
+        eosApertureValueMap.put(0x0D, "1.2"); // (1/3)");
450 
+        eosApertureValueMap.put(0x10, "1.4");
451 
+        eosApertureValueMap.put(0x13, "1.6");
452 
+        eosApertureValueMap.put(0x14, "1.8");
453 
+        eosApertureValueMap.put(0x15, "1.8"); // (1/3)");
454 
+        eosApertureValueMap.put(0x18, "2");
455 
+        eosApertureValueMap.put(0x1B, "2.2");
456 
+        eosApertureValueMap.put(0x1C, "2.5");
457 
+        eosApertureValueMap.put(0x1D, "2.5"); // (1/3)");
458 
+        eosApertureValueMap.put(0x20, "2.8");
459 
+        eosApertureValueMap.put(0x23, "3.2");
460 
+        eosApertureValueMap.put(0x24, "3.5");
461 
+        eosApertureValueMap.put(0x25, "3.5"); // (1/3)");
462 
+        eosApertureValueMap.put(0x28, "4");
463 
+        eosApertureValueMap.put(0x2B, "4.5");
464 
+        eosApertureValueMap.put(0x2C, "4.5");
465 
+        eosApertureValueMap.put(0x2D, "5.0");
466 
+        eosApertureValueMap.put(0x30, "5.6");
467 
+        eosApertureValueMap.put(0x33, "6.3");
468 
+        eosApertureValueMap.put(0x34, "6.7");
469 
+        eosApertureValueMap.put(0x35, "7.1");
470 
+        eosApertureValueMap.put(0x38, "8");
471 
+        eosApertureValueMap.put(0x3B, "9");
472 
+        eosApertureValueMap.put(0x3C, "9.5");
473 
+        eosApertureValueMap.put(0x3D, "10");
474 
+        eosApertureValueMap.put(0x40, "11");
475 
+        eosApertureValueMap.put(0x43, "13"); // (1/3)");
476 
+        eosApertureValueMap.put(0x44, "13");
477 
+        eosApertureValueMap.put(0x45, "14");
478 
+        eosApertureValueMap.put(0x48, "16");
479 
+        eosApertureValueMap.put(0x4B, "18");
480 
+        eosApertureValueMap.put(0x4C, "19");
481 
+        eosApertureValueMap.put(0x4D, "20");
482 
+        eosApertureValueMap.put(0x50, "22");
483 
+        eosApertureValueMap.put(0x53, "25");
484 
+        eosApertureValueMap.put(0x54, "27");
485 
+        eosApertureValueMap.put(0x55, "29");
486 
+        eosApertureValueMap.put(0x58, "32");
487 
+        eosApertureValueMap.put(0x5B, "36");
488 
+        eosApertureValueMap.put(0x5C, "38");
489 
+        eosApertureValueMap.put(0x5D, "40");
490 
+        eosApertureValueMap.put(0x60, "45");
491 
+        eosApertureValueMap.put(0x63, "51");
492 
+        eosApertureValueMap.put(0x64, "54");
493 
+        eosApertureValueMap.put(0x65, "57");
494 
+        eosApertureValueMap.put(0x68, "64");
495 
+        eosApertureValueMap.put(0x6B, "72");
496 
+        eosApertureValueMap.put(0x6C, "76");
497 
+        eosApertureValueMap.put(0x6D, "80");
498 
+        eosApertureValueMap.put(0x70, "91");
499 
+
500 
+        eosIsoSpeedMap.put(0x00, "Auto");
501 
+        eosIsoSpeedMap.put(0x28, "6");
502 
+        eosIsoSpeedMap.put(0x30, "12");
503 
+        eosIsoSpeedMap.put(0x38, "25");
504 
+        eosIsoSpeedMap.put(0x40, "50");
505 
+        eosIsoSpeedMap.put(0x48, "100");
506 
+        eosIsoSpeedMap.put(0x4b, "125");
507 
+        eosIsoSpeedMap.put(0x4d, "160");
508 
+        eosIsoSpeedMap.put(0x50, "200");
509 
+        eosIsoSpeedMap.put(0x53, "250");
510 
+        eosIsoSpeedMap.put(0x55, "320");
511 
+        eosIsoSpeedMap.put(0x58, "400");
512 
+        eosIsoSpeedMap.put(0x5b, "500");
513 
+        eosIsoSpeedMap.put(0x5d, "640");
514 
+        eosIsoSpeedMap.put(0x60, "800");
515 
+        eosIsoSpeedMap.put(0x63, "1000");
516 
+        eosIsoSpeedMap.put(0x65, "1250");
517 
+        eosIsoSpeedMap.put(0x68, "1600");
518 
+        eosIsoSpeedMap.put(0x6b, "2000");
519 
+        eosIsoSpeedMap.put(0x6d, "2500");
520 
+        eosIsoSpeedMap.put(0x70, "3200");
521 
+        eosIsoSpeedMap.put(0x73, "4000");
522 
+        eosIsoSpeedMap.put(0x75, "5000");
523 
+        eosIsoSpeedMap.put(0x78, "6400");
524 
+        eosIsoSpeedMap.put(0x80, "12800");
525 
+        eosIsoSpeedMap.put(0x88, "25600");
526 
+        eosIsoSpeedMap.put(0x90, "51200");
527 
+        eosIsoSpeedMap.put(0x98, "102400");
528 
+
529 
+        eosWhitebalanceMap.put(0, "Auto");
530 
+        eosWhitebalanceMap.put(1, "Daylight");
531 
+        eosWhitebalanceMap.put(2, "Cloudy");
532 
+        eosWhitebalanceMap.put(3, "Tungsten");
533 
+        eosWhitebalanceMap.put(4, "Fluorescent");
534 
+        eosWhitebalanceMap.put(5, "Flash");
535 
+        eosWhitebalanceMap.put(6, "Manual 1");
536 
+        eosWhitebalanceMap.put(8, "Shade");
537 
+        eosWhitebalanceMap.put(9, "Color temperature");
538 
+        eosWhitebalanceMap.put(10, "PC-1");
539 
+        eosWhitebalanceMap.put(11, "PC-2");
540 
+        eosWhitebalanceMap.put(12, "PC-3");
541 
+        eosWhitebalanceMap.put(15, "Manual 2");
542 
+        eosWhitebalanceMap.put(16, "Manual 3");
543 
+        eosWhitebalanceMap.put(18, "Manual 4");
544 
+        eosWhitebalanceMap.put(19, "Manual");
545 
+        eosWhitebalanceMap.put(20, "PC-4");
546 
+        eosWhitebalanceMap.put(21, "PC-5");
547 
+
548 
+//        eosWhitebalanceIconsMap.put(0, R.drawable.whitebalance_auto);
549 
+//        eosWhitebalanceIconsMap.put(1, R.drawable.whitebalance_daylight);
550 
+//        eosWhitebalanceIconsMap.put(2, R.drawable.whitebalance_cloudy);
551 
+//        eosWhitebalanceIconsMap.put(3, R.drawable.whitebalance_tungsten);
552 
+//        eosWhitebalanceIconsMap.put(4, R.drawable.whitebalance_fluorescent);
553 
+//        eosWhitebalanceIconsMap.put(5, R.drawable.whitebalance_flash);
554 
+//        eosWhitebalanceIconsMap.put(6, R.drawable.whitebalance_manual1);
555 
+//        eosWhitebalanceIconsMap.put(8, R.drawable.whitebalance_shade);
556 
+//        eosWhitebalanceIconsMap.put(9, R.drawable.whitebalance_color_temperature);
557 
+//        eosWhitebalanceIconsMap.put(10, R.drawable.whitebalance_custom1);
558 
+//        eosWhitebalanceIconsMap.put(11, R.drawable.whitebalance_custom2);
559 
+//        eosWhitebalanceIconsMap.put(12, R.drawable.whitebalance_custom3);
560 
+//        eosWhitebalanceIconsMap.put(15, R.drawable.whitebalance_manual2);
561 
+//        eosWhitebalanceIconsMap.put(16, R.drawable.whitebalance_manual3);
562 
+//        eosWhitebalanceIconsMap.put(18, R.drawable.whitebalance_manual4);
563 
+//        eosWhitebalanceIconsMap.put(19, R.drawable.whitebalance_manual5);
564 
+//        eosWhitebalanceIconsMap.put(20, R.drawable.whitebalance_custom4);
565 
+//        eosWhitebalanceIconsMap.put(21, R.drawable.whitebalance_custom5);
566 
+
567 
+        eosShootingModeMap.put(0, "Program AE");
568 
+        eosShootingModeMap.put(1, "Shutter-Speed Priority AE");
569 
+        eosShootingModeMap.put(2, "Aperture Priority AE");
570 
+        eosShootingModeMap.put(3, "Manual Exposure");
571 
+        eosShootingModeMap.put(4, "Bulb");
572 
+        eosShootingModeMap.put(5, "Auto Depth-of-Field AE");
573 
+        eosShootingModeMap.put(6, "Depth-of-Field AE");
574 
+        eosShootingModeMap.put(8, "Lock");
575 
+        eosShootingModeMap.put(9, "Auto");
576 
+        eosShootingModeMap.put(10, "Night Scene Portrait");
577 
+        eosShootingModeMap.put(11, "Sports");
578 
+        eosShootingModeMap.put(12, "Portrait");
579 
+        eosShootingModeMap.put(13, "Landscape");
580 
+        eosShootingModeMap.put(14, "Close-Up");
581 
+        eosShootingModeMap.put(15, "Flash Off");
582 
+        eosShootingModeMap.put(19, "Creative Auto");
583 
+
584 
+//        eosShootingModeIconsMap.put(0, R.drawable.shootingmode_program);
585 
+//        eosShootingModeIconsMap.put(1, R.drawable.shootingmode_tv);
586 
+//        eosShootingModeIconsMap.put(2, R.drawable.shootingmode_av);
587 
+//        eosShootingModeIconsMap.put(3, R.drawable.shootingmode_m);
588 
+//        eosShootingModeIconsMap.put(4, R.drawable.shootingmode_bulb);
589 
+//        eosShootingModeIconsMap.put(5, R.drawable.shootingmode_adep);
590 
+//        eosShootingModeIconsMap.put(6, R.drawable.shootingmode_dep);
591 
+//        eosShootingModeIconsMap.put(8, R.drawable.shootingmode_lock);
592 
+//        eosShootingModeIconsMap.put(9, R.drawable.shootingmode_auto);
593 
+//        eosShootingModeIconsMap.put(10, R.drawable.shootingmode_night_scene_portrait);
594 
+//        eosShootingModeIconsMap.put(11, R.drawable.shootingmode_sports);
595 
+//        eosShootingModeIconsMap.put(12, R.drawable.shootingmode_portrait);
596 
+//        eosShootingModeIconsMap.put(13, R.drawable.shootingmode_landscape);
597 
+//        eosShootingModeIconsMap.put(14, R.drawable.shootingmode_close_up);
598 
+//        eosShootingModeIconsMap.put(15, R.drawable.shootingmode_flash_off);
599 
+//        eosShootingModeIconsMap.put(19, R.drawable.shootingmode_creativeauto);
600 
+
601 
+        eosDriveModeMap.put(0, "Single Shooting");
602 
+        eosDriveModeMap.put(1, "Continuous Shooting");
603 
+        eosDriveModeMap.put(2, "Video");
604 
+        eosDriveModeMap.put(3, "?");
605 
+        eosDriveModeMap.put(4, "High-Speed Continuous Shooting");
606 
+        eosDriveModeMap.put(5, "Low-Speed Continuous Shooting");
607 
+        eosDriveModeMap.put(6, "Silent Single Shooting");
608 
+        eosDriveModeMap.put(7, "10-Sec Self-Timer plus Continuous Shooting");
609 
+        eosDriveModeMap.put(0x10, "10-Sec Self-Timer");
610 
+        eosDriveModeMap.put(0x11, "2-Sec Self-Timer");
611 
+
612 
+        // TODO easDriveModeIconsmap
613 
+
614 
+        eosFocusModeMap.put(0, "One-Shot AF");
615 
+        eosFocusModeMap.put(1, "AI Servo AF");
616 
+        eosFocusModeMap.put(2, "AI Focus AF");
617 
+        eosFocusModeMap.put(3, "Manual Focus");
618 
+
619 
+        nikonWhitebalanceMap.put(2, "Auto");
620 
+        nikonWhitebalanceMap.put(4, "Sunny");
621 
+        nikonWhitebalanceMap.put(5, "Fluorescent");
622 
+        nikonWhitebalanceMap.put(6, "Incandescent");
623 
+        nikonWhitebalanceMap.put(7, "Flash");
624 
+        nikonWhitebalanceMap.put(0x8010, "Cloudy");
625 
+        nikonWhitebalanceMap.put(0x8011, "Sunny shade");
626 
+        nikonWhitebalanceMap.put(0x8012, "Color temperature");
627 
+        nikonWhitebalanceMap.put(0x8013, "Preset");
628 
+
629 
+//        nikonWhitebalanceIconsMap.put(2, R.drawable.whitebalance_auto);
630 
+//        nikonWhitebalanceIconsMap.put(4, R.drawable.whitebalance_daylight);
631 
+//        nikonWhitebalanceIconsMap.put(5, R.drawable.whitebalance_fluorescent);
632 
+//        nikonWhitebalanceIconsMap.put(6, R.drawable.whitebalance_tungsten);
633 
+//        nikonWhitebalanceIconsMap.put(7, R.drawable.whitebalance_flash);
634 
+//        nikonWhitebalanceIconsMap.put(0x8010, R.drawable.whitebalance_cloudy);
635 
+//        nikonWhitebalanceIconsMap.put(0x8011, R.drawable.whitebalance_shade);
636 
+//        nikonWhitebalanceIconsMap.put(0x8012, R.drawable.whitebalance_color_temperature);
637 
+//        nikonWhitebalanceIconsMap.put(0x8013, R.drawable.whitebalance_custom1); // TODO create Nikon specific icon
638 
+
639 
+        nikonExposureIndexMap.put(0x0064, "100");
640 
+        nikonExposureIndexMap.put(0x007D, "125");
641 
+        nikonExposureIndexMap.put(0x00A0, "160");
642 
+        nikonExposureIndexMap.put(0x00C8, "200");
643 
+        nikonExposureIndexMap.put(0x00FA, "250");
644 
+        nikonExposureIndexMap.put(0x0118, "280");
645 
+        nikonExposureIndexMap.put(0x0140, "320");
646 
+        nikonExposureIndexMap.put(0x0190, "400");
647 
+        nikonExposureIndexMap.put(0x01F4, "500");
648 
+        nikonExposureIndexMap.put(0x0230, "560");
649 
+        nikonExposureIndexMap.put(0x0280, "640");
650 
+        nikonExposureIndexMap.put(0x0320, "800");
651 
+        nikonExposureIndexMap.put(0x03E8, "1000");
652 
+        nikonExposureIndexMap.put(0x044C, "1100");
653 
+        nikonExposureIndexMap.put(0x04E2, "1250");
654 
+        nikonExposureIndexMap.put(0x0640, "1600");
655 
+        nikonExposureIndexMap.put(0x07D0, "2000");
656 
+        nikonExposureIndexMap.put(0x0898, "2200");
657 
+        nikonExposureIndexMap.put(0x09C4, "2500");
658 
+        nikonExposureIndexMap.put(0x0C80, "3200");
659 
+        nikonExposureIndexMap.put(0x0FA0, "4000");
660 
+        nikonExposureIndexMap.put(0x1194, "4500");
661 
+        nikonExposureIndexMap.put(0x1388, "5000");
662 
+        nikonExposureIndexMap.put(0x1900, "6400");
663 
+        nikonExposureIndexMap.put(0x1F40, "8000");
664 
+        nikonExposureIndexMap.put(0x2328, "9000");
665 
+        nikonExposureIndexMap.put(0x2710, "10000");
666 
+        nikonExposureIndexMap.put(0x3200, "12800");
667 
+
668 
+//        nikonExposureProgramMap.put(0x0001, R.drawable.shootingmode_m);
669 
+//        nikonExposureProgramMap.put(0x0002, R.drawable.shootingmode_program);
670 
+//        nikonExposureProgramMap.put(0x0003, R.drawable.shootingmode_av);
671 
+//        nikonExposureProgramMap.put(0x0004, R.drawable.shootingmode_tv);
672 
+//        nikonExposureProgramMap.put(0x8010, R.drawable.shootingmode_auto);
673 
+//        nikonExposureProgramMap.put(0x8011, R.drawable.shootingmode_portrait);
674 
+//        nikonExposureProgramMap.put(0x8012, R.drawable.shootingmode_landscape);
675 
+//        nikonExposureProgramMap.put(0x8013, R.drawable.shootingmode_close_up);
676 
+//        nikonExposureProgramMap.put(0x8014, R.drawable.shootingmode_sports);
677 
+//        nikonExposureProgramMap.put(0x8015, R.drawable.shootingmode_night_scene_portrait);
678 
+//        nikonExposureProgramMap.put(0x8016, R.drawable.shootingmode_flash_off);
679 
+//        nikonExposureProgramMap.put(0x8017, R.drawable.shootingmode_unknown); // TODO Child
680 
+//        nikonExposureProgramMap.put(0x8018, R.drawable.shootingmode_unknown); // TODO SCENE
681 
+//        nikonExposureProgramMap.put(0x8050, R.drawable.shootingmode_unknown); // TODO User mode U1
682 
+//        nikonExposureProgramMap.put(0x8051, R.drawable.shootingmode_unknown); // TODO User mode U2
683 
+
684 
+        nikonWbColorTempD300SMap.put(0, "2500K");
685 
+        nikonWbColorTempD300SMap.put(1, "2560K");
686 
+        nikonWbColorTempD300SMap.put(2, "2630K");
687 
+        nikonWbColorTempD300SMap.put(3, "2700K");
688 
+        nikonWbColorTempD300SMap.put(4, "2780K");
689 
+        nikonWbColorTempD300SMap.put(5, "2860K");
690 
+        nikonWbColorTempD300SMap.put(6, "2940K");
691 
+        nikonWbColorTempD300SMap.put(7, "3030K");
692 
+        nikonWbColorTempD300SMap.put(8, "3130K");
693 
+        nikonWbColorTempD300SMap.put(9, "3230K");
694 
+        nikonWbColorTempD300SMap.put(10, "3330K");
695 
+        nikonWbColorTempD300SMap.put(11, "3450K");
696 
+        nikonWbColorTempD300SMap.put(12, "3570K");
697 
+        nikonWbColorTempD300SMap.put(13, "3700K");
698 
+        nikonWbColorTempD300SMap.put(14, "3850K");
699 
+        nikonWbColorTempD300SMap.put(15, "4000K");
700 
+        nikonWbColorTempD300SMap.put(16, "4170K");
701 
+        nikonWbColorTempD300SMap.put(17, "4350K");
702 
+        nikonWbColorTempD300SMap.put(18, "4550K");
703 
+        nikonWbColorTempD300SMap.put(19, "4760K");
704 
+        nikonWbColorTempD300SMap.put(20, "5000K");
705 
+        nikonWbColorTempD300SMap.put(21, "5260K");
706 
+        nikonWbColorTempD300SMap.put(22, "5560K");
707 
+        nikonWbColorTempD300SMap.put(23, "5880K");
708 
+        nikonWbColorTempD300SMap.put(24, "6250K");
709 
+        nikonWbColorTempD300SMap.put(25, "6670K");
710 
+        nikonWbColorTempD300SMap.put(26, "7140K");
711 
+        nikonWbColorTempD300SMap.put(27, "7690K");
712 
+        nikonWbColorTempD300SMap.put(28, "8330K");
713 
+        nikonWbColorTempD300SMap.put(29, "9090K");
714 
+        nikonWbColorTempD300SMap.put(30, "10000K");
715 
+
716 
+        nikonWbColorTempD200Map.put(0, "2500K");
717 
+        nikonWbColorTempD200Map.put(1, "2550K");
718 
+        nikonWbColorTempD200Map.put(2, "2650K");
719 
+        nikonWbColorTempD200Map.put(3, "2700K");
720 
+        nikonWbColorTempD200Map.put(4, "2800K");
721 
+        nikonWbColorTempD200Map.put(5, "2850K");
722 
+        nikonWbColorTempD200Map.put(6, "2950K");
723 
+        nikonWbColorTempD200Map.put(7, "3000K");
724 
+        nikonWbColorTempD200Map.put(8, "3100K");
725 
+        nikonWbColorTempD200Map.put(9, "3200K");
726 
+        nikonWbColorTempD200Map.put(10, "3300K");
727 
+        nikonWbColorTempD200Map.put(11, "3400K");
728 
+        nikonWbColorTempD200Map.put(12, "3600K");
729 
+        nikonWbColorTempD200Map.put(13, "3700K");
730 
+        nikonWbColorTempD200Map.put(14, "3800K");
731 
+        nikonWbColorTempD200Map.put(15, "4000K");
732 
+        nikonWbColorTempD200Map.put(16, "4200K");
733 
+        nikonWbColorTempD200Map.put(17, "4300K");
734 
+        nikonWbColorTempD200Map.put(18, "4500K");
735 
+        nikonWbColorTempD200Map.put(19, "4800K");
736 
+        nikonWbColorTempD200Map.put(20, "5000K");
737 
+        nikonWbColorTempD200Map.put(21, "5300K");
738 
+        nikonWbColorTempD200Map.put(22, "5600K");
739 
+        nikonWbColorTempD200Map.put(23, "5900K");
740 
+        nikonWbColorTempD200Map.put(24, "6300K");
741 
+        nikonWbColorTempD200Map.put(25, "6700K");
742 
+        nikonWbColorTempD200Map.put(26, "7100K");
743 
+        nikonWbColorTempD200Map.put(27, "7700K");
744 
+        nikonWbColorTempD200Map.put(28, "8300K");
745 
+        nikonWbColorTempD200Map.put(29, "9100K");
746 
+        nikonWbColorTempD200Map.put(30, "10000K");
747 
+
748 
+        nikonFocusModeMap.put(0x0001, "Manual Focus");
749 
+        nikonFocusModeMap.put(0x8010, "Single AF servo");
750 
+        nikonFocusModeMap.put(0x8011, "Continous AF servo");
751 
+        nikonFocusModeMap.put(0x8012, "AF servo auto switch");
752 
+        nikonFocusModeMap.put(0x8013, "Constant AF servo");
753 
+
754 
+        nikonActivePicCtrlItemMap.put(1, "SD");
755 
+        nikonActivePicCtrlItemMap.put(2, "NL");
756 
+        nikonActivePicCtrlItemMap.put(3, "VI");
757 
+        nikonActivePicCtrlItemMap.put(4, "MC");
758 
+        nikonActivePicCtrlItemMap.put(5, "PT");
759 
+        nikonActivePicCtrlItemMap.put(6, "LS");
760 
+        nikonActivePicCtrlItemMap.put(101, "O-1");
761 
+        nikonActivePicCtrlItemMap.put(102, "O-2");
762 
+        nikonActivePicCtrlItemMap.put(103, "O-3");
763 
+        nikonActivePicCtrlItemMap.put(104, "O-4");
764 
+        nikonActivePicCtrlItemMap.put(201, "C-1");
765 
+        nikonActivePicCtrlItemMap.put(202, "C-2");
766 
+        nikonActivePicCtrlItemMap.put(203, "C-3");
767 
+        nikonActivePicCtrlItemMap.put(204, "C-4");
768 
+        nikonActivePicCtrlItemMap.put(205, "C-5");
769 
+        nikonActivePicCtrlItemMap.put(206, "C-6");
770 
+        nikonActivePicCtrlItemMap.put(207, "C-7");
771 
+        nikonActivePicCtrlItemMap.put(208, "C-8");
772 
+        nikonActivePicCtrlItemMap.put(209, "C-9");
773 
+
774 
+//        nikonMeteringModeMap.put(2, R.drawable.metering_exposure_center_weighted_nikon);
775 
+//        nikonMeteringModeMap.put(3, R.drawable.metering_exposure_matrix_nikon);
776 
+//        nikonMeteringModeMap.put(4, R.drawable.metering_exposure_spot);
777 
+//
778 
+//        eosMeteringModeIconsMap.put(1, R.drawable.metering_exposure_spot);
779 
+//        eosMeteringModeIconsMap.put(3, R.drawable.metering_exposure_evaluative_canon);
780 
+//        eosMeteringModeIconsMap.put(4, R.drawable.metering_exposure_partial);
781 
+//        eosMeteringModeIconsMap.put(5, R.drawable.metering_exposure_center_weighted_average_canon);
782 
+
783 
+        nikonFocusMeteringModeMap.put(0x0002, "Dynamic");
784 
+        nikonFocusMeteringModeMap.put(0x8010, "Single point");
785 
+        nikonFocusMeteringModeMap.put(0x8011, "Auto area");
786 
+        nikonFocusMeteringModeMap.put(0x8012, "3D");
787 
+
788 
+//        nikonFocusMeteringModeIconsMap.put(0x0002, R.drawable.metering_af_dynamic_area);
789 
+//        nikonFocusMeteringModeIconsMap.put(0x8010, R.drawable.metering_af_single_point);
790 
+//        nikonFocusMeteringModeIconsMap.put(0x8011, R.drawable.metering_af_auto_area);
791 
+//        nikonFocusMeteringModeIconsMap.put(0x8012, R.drawable.metering_af_3d_tracking);
792 
+
793 
+        eosPictureStyleMap.put(0x81, "ST");
794 
+        eosPictureStyleMap.put(0x82, "PT");
795 
+        eosPictureStyleMap.put(0x83, "LS");
796 
+        eosPictureStyleMap.put(0x84, "NL");
797 
+        eosPictureStyleMap.put(0x85, "FL");
798 
+        eosPictureStyleMap.put(0x86, "MO");
799 
+        eosPictureStyleMap.put(0x21, "UD1");
800 
+        eosPictureStyleMap.put(0x22, "UD2");
801 
+        eosPictureStyleMap.put(0x23, "UD3");
802 
+    }
803 
+}

+ 47 - 0
app/src/main/java/com/remoteyourcam/usb/ptp/PtpService.java
Преглед на файла 

@@ -0,0 +1,47 @@
1 
+/**
2 
+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech
3 
+ *
4 
+ * Licensed under the Apache License, Version 2.0 (the "License");
5 
+ * you may not use this file except in compliance with the License.
6 
+ * You may obtain a copy of the License at
7 
+ *
8 
+ *     http://www.apache.org/licenses/LICENSE-2.0
9 
+ *
10 
+ * Unless required by applicable law or agreed to in writing, software
11 
+ * distributed under the License is distributed on an "AS IS" BASIS,
12 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 
+ * See the License for the specific language governing permissions and
14 
+ * limitations under the License.
15 
+ */
16 
+package com.remoteyourcam.usb.ptp;
17 
+
18 
+import com.remoteyourcam.usb.ptp.Camera.CameraListener;
19 
+
20 
+import android.content.Context;
21 
+import android.content.Intent;
22 
+
23 
+public interface PtpService {
24 
+
25 
+    void setCameraListener(CameraListener listener);
26 
+
27 
+    void initialize(Context context, Intent intent);
28 
+
29 
+    void shutdown();
30 
+
31 
+    void lazyShutdown();
32 
+
33 
+    public static class Singleton {
34 
+        private static PtpService singleton;
35 
+
36 
+        public static PtpService getInstance(Context context) {
37 
+            if (singleton == null) {
38 
+                singleton = new PtpUsbService(context);
39 
+            }
40 
+            return singleton;
41 
+        }
42 
+
43 
+        public static void setInstance(PtpService service) {
44 
+            singleton = service;
45 
+        }
46 
+    }
47 
+}

+ 76 - 0
app/src/main/java/com/remoteyourcam/usb/ptp/PtpUsbConnection.java
Преглед на файла 

@@ -0,0 +1,76 @@
1 
+/**
2 
+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech
3 
+ *
4 
+ * Licensed under the Apache License, Version 2.0 (the "License");
5 
+ * you may not use this file except in compliance with the License.
6 
+ * You may obtain a copy of the License at
7 
+ *
8 
+ *     http://www.apache.org/licenses/LICENSE-2.0
9 
+ *
10 
+ * Unless required by applicable law or agreed to in writing, software
11 
+ * distributed under the License is distributed on an "AS IS" BASIS,
12 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 
+ * See the License for the specific language governing permissions and
14 
+ * limitations under the License.
15 
+ */
16 
+package com.remoteyourcam.usb.ptp;
17 
+
18 
+import android.hardware.usb.UsbDeviceConnection;
19 
+import android.hardware.usb.UsbEndpoint;
20 
+import android.hardware.usb.UsbRequest;
21 
+
22 
+public class PtpUsbConnection {
23 
+
24 
+    private final UsbDeviceConnection connection;
25 
+    private final UsbEndpoint bulkOut;
26 
+    private final UsbEndpoint bulkIn;
27 
+    private final int vendorId;
28 
+    private final int productId;
29 
+
30 
+    public PtpUsbConnection(UsbDeviceConnection connection, UsbEndpoint bulkIn, UsbEndpoint bulkOut, int vendorId,
31 
+            int productId) {
32 
+        this.connection = connection;
33 
+        this.bulkIn = bulkIn;
34 
+        this.bulkOut = bulkOut;
35 
+        this.vendorId = vendorId;
36 
+        this.productId = productId;
37 
+    }
38 
+
39 
+    public int getVendorId() {
40 
+        return vendorId;
41 
+    }
42 
+
43 
+    public int getProductId() {
44 
+        return productId;
45 
+    }
46 
+
47 
+    public void close() {
48 
+        connection.close();
49 
+    }
50 
+
51 
+    public int getMaxPacketInSize() {
52 
+        return bulkIn.getMaxPacketSize();
53 
+    }
54 
+
55 
+    public int getMaxPacketOutSize() {
56 
+        return bulkOut.getMaxPacketSize();
57 
+    }
58 
+
59 
+    public UsbRequest createInRequest() {
60 
+        UsbRequest r = new UsbRequest();
61 
+        r.initialize(connection, bulkIn);
62 
+        return r;
63 
+    }
64 
+
65 
+    public int bulkTransferOut(byte[] buffer, int length, int timeout) {
66 
+        return connection.bulkTransfer(bulkOut, buffer, length, timeout);
67 
+    }
68 
+
69 
+    public int bulkTransferIn(byte[] buffer, int maxLength, int timeout) {
70 
+        return connection.bulkTransfer(bulkIn, buffer, maxLength, timeout);
71 
+    }
72 
+
73 
+    public void requestWait() {
74 
+        connection.requestWait();
75 
+    }
76 
+}

+ 228 - 0
app/src/main/java/com/remoteyourcam/usb/ptp/PtpUsbService.java
Преглед на файла 

@@ -0,0 +1,228 @@
1 
+/**
2 
+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech
3 
+ *
4 
+ * Licensed under the Apache License, Version 2.0 (the "License");
5 
+ * you may not use this file except in compliance with the License.
6 
+ * You may obtain a copy of the License at
7 
+ *
8 
+ *     http://www.apache.org/licenses/LICENSE-2.0
9 
+ *
10 
+ * Unless required by applicable law or agreed to in writing, software
11 
+ * distributed under the License is distributed on an "AS IS" BASIS,
12 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 
+ * See the License for the specific language governing permissions and
14 
+ * limitations under the License.
15 
+ */
16 
+package com.remoteyourcam.usb.ptp;
17 
+
18 
+import java.util.Map;
19 
+
20 
+import android.app.PendingIntent;
21 
+import android.content.BroadcastReceiver;
22 
+import android.content.Context;
23 
+import android.content.Intent;
24 
+import android.content.IntentFilter;
25 
+import android.hardware.usb.UsbConstants;
26 
+import android.hardware.usb.UsbDevice;
27 
+import android.hardware.usb.UsbEndpoint;
28 
+import android.hardware.usb.UsbInterface;
29 
+import android.hardware.usb.UsbManager;
30 
+import android.os.Handler;
31 
+import android.util.Log;
32 
+
33 
+import com.remoteyourcam.usb.AppConfig;
34 
+import com.remoteyourcam.usb.ptp.Camera.CameraListener;
35 
+import com.remoteyourcam.usb.ptp.PtpCamera.State;
36 
+
37 
+public class PtpUsbService implements PtpService {
38 
+
39 
+    private final String TAG = PtpUsbService.class.getSimpleName();
40 
+
41 
+    private static final String ACTION_USB_PERMISSION = "com.android.example.USB_PERMISSION";
42 
+    private final BroadcastReceiver permissonReceiver = new BroadcastReceiver() {
43 
+        @Override
44 
+        public void onReceive(Context context, Intent intent) {
45 
+            String action = intent.getAction();
46 
+            if (ACTION_USB_PERMISSION.equals(action)) {
47 
+                unregisterPermissionReceiver(context);
48 
+                synchronized (this) {
49 
+                    UsbDevice device = (UsbDevice) intent.getParcelableExtra(UsbManager.EXTRA_DEVICE);
50 
+
51 
+                    if (intent.getBooleanExtra(UsbManager.EXTRA_PERMISSION_GRANTED, false)) {
52 
+                        connect(context, device);
53 
+                    } else {
54 
+                        //TODO report
55 
+                    }
56 
+                }
57 
+            }
58 
+        }
59 
+    };
60 
+
61 
+    private final Handler handler = new Handler();
62 
+    private final UsbManager usbManager;
63 
+    private PtpCamera camera;
64 
+    private CameraListener listener;
65 
+
66 
+    Runnable shutdownRunnable = new Runnable() {
67 
+        @Override
68 
+        public void run() {
69 
+            shutdown();
70 
+        }
71 
+    };
72 
+
73 
+    public PtpUsbService(Context context) {
74 
+        this.usbManager = (UsbManager) context.getSystemService(Context.USB_SERVICE);
75 
+    }
76 
+
77 
+    @Override
78 
+    public void setCameraListener(CameraListener listener) {
79 
+        this.listener = listener;
80 
+        if (camera != null) {
81 
+            camera.setListener(listener);
82 
+        }
83 
+    }
84 
+
85 
+    @Override
86 
+    public void initialize(Context context, Intent intent) {
87 
+        handler.removeCallbacks(shutdownRunnable);
88 
+        if (camera != null) {
89 
+            if (AppConfig.LOG) {
90 
+                Log.i(TAG, "initialize: camera available");
91 
+            }
92 
+            if (camera.getState() == State.Active) {
93 
+                if (listener != null) {
94 
+                    listener.onCameraStarted(camera);
95 
+                }
96 
+                return;
97 
+            }
98 
+            if (AppConfig.LOG) {
99 
+                Log.i(TAG, "initialize: camera not active, satet " + camera.getState());
100 
+            }
101 
+            camera.shutdownHard();
102 
+        }
103 
+        UsbDevice device = (UsbDevice) intent.getParcelableExtra(UsbManager.EXTRA_DEVICE);
104 
+        if (device != null) {
105 
+            if (AppConfig.LOG) {
106 
+                Log.i(TAG, "initialize: got device through intent");
107 
+            }
108 
+            connect(context, device);
109 
+        } else {
110 
+            if (AppConfig.LOG) {
111 
+                Log.i(TAG, "initialize: looking for compatible camera");
112 
+            }
113 
+            device = lookupCompatibleDevice(usbManager);
114 
+            if (device != null) {
115 
+                registerPermissionReceiver(context);
116 
+                PendingIntent mPermissionIntent = PendingIntent.getBroadcast(context, 0, new Intent(
117 
+                        ACTION_USB_PERMISSION), 0);
118 
+                usbManager.requestPermission(device, mPermissionIntent);
119 
+            } else {
120 
+                listener.onNoCameraFound();
121 
+            }
122 
+        }
123 
+    }
124 
+
125 
+    @Override
126 
+    public void shutdown() {
127 
+        if (AppConfig.LOG) {
128 
+            Log.i(TAG, "shutdown");
129 
+        }
130 
+        if (camera != null) {
131 
+            camera.shutdown();
132 
+            camera = null;
133 
+        }
134 
+    }
135 
+
136 
+    @Override
137 
+    public void lazyShutdown() {
138 
+        if (AppConfig.LOG) {
139 
+            Log.i(TAG, "lazy shutdown");
140 
+        }
141 
+        handler.postDelayed(shutdownRunnable, 4000);
142 
+    }
143 
+
144 
+    private void registerPermissionReceiver(Context context) {
145 
+        if (AppConfig.LOG) {
146 
+            Log.i(TAG, "register permission receiver");
147 
+        }
148 
+        IntentFilter filter = new IntentFilter(ACTION_USB_PERMISSION);
149 
+        context.registerReceiver(permissonReceiver, filter);
150 
+    }
151 
+
152 
+    private void unregisterPermissionReceiver(Context context) {
153 
+        if (AppConfig.LOG) {
154 
+            Log.i(TAG, "unregister permission receiver");
155 
+        }
156 
+        context.unregisterReceiver(permissonReceiver);
157 
+    }
158 
+
159 
+    private UsbDevice lookupCompatibleDevice(UsbManager manager) {
160 
+        Map<String, UsbDevice> deviceList = manager.getDeviceList();
161 
+        for (Map.Entry<String, UsbDevice> e : deviceList.entrySet()) {
162 
+            UsbDevice d = e.getValue();
163 
+            if (d.getVendorId() == PtpConstants.CanonVendorId || d.getVendorId() == PtpConstants.NikonVendorId) {
164 
+                return d;
165 
+            }
166 
+        }
167 
+        return null;
168 
+    }
169 
+
170 
+    private boolean connect(Context context, UsbDevice device) {
171 
+        if (camera != null) {
172 
+            camera.shutdown();
173 
+            camera = null;
174 
+        }
175 
+        for (int i = 0, n = device.getInterfaceCount(); i < n; ++i) {
176 
+            UsbInterface intf = device.getInterface(i);
177 
+
178 
+            if (intf.getEndpointCount() != 3) {
179 
+                continue;
180 
+            }
181 
+
182 
+            UsbEndpoint in = null;
183 
+            UsbEndpoint out = null;
184 
+
185 
+            for (int e = 0, en = intf.getEndpointCount(); e < en; ++e) {
186 
+                UsbEndpoint endpoint = intf.getEndpoint(e);
187 
+                if (endpoint.getType() == UsbConstants.USB_ENDPOINT_XFER_BULK) {
188 
+                    if (endpoint.getDirection() == UsbConstants.USB_DIR_IN) {
189 
+                        in = endpoint;
190 
+                    } else if (endpoint.getDirection() == UsbConstants.USB_DIR_OUT) {
191 
+                        out = endpoint;
192 
+                    }
193 
+                }
194 
+            }
195 
+
196 
+            if (in == null || out == null) {
197 
+                continue;
198 
+            }
199 
+
200 
+            if (AppConfig.LOG) {
201 
+                Log.i(TAG, "Found compatible USB interface");
202 
+                Log.i(TAG, "Interface class " + intf.getInterfaceClass());
203 
+                Log.i(TAG, "Interface subclass " + intf.getInterfaceSubclass());
204 
+                Log.i(TAG, "Interface protocol " + intf.getInterfaceProtocol());
205 
+                Log.i(TAG, "Bulk out max size " + out.getMaxPacketSize());
206 
+                Log.i(TAG, "Bulk in max size " + in.getMaxPacketSize());
207 
+            }
208 
+
209 
+            if (device.getVendorId() == PtpConstants.CanonVendorId) {
210 
+                PtpUsbConnection connection = new PtpUsbConnection(usbManager.openDevice(device), in, out,
211 
+                        device.getVendorId(), device.getProductId());
212 
+                camera = new EosCamera(connection, listener, new WorkerNotifier(context));
213 
+            } else if (device.getVendorId() == PtpConstants.NikonVendorId) {
214 
+                PtpUsbConnection connection = new PtpUsbConnection(usbManager.openDevice(device), in, out,
215 
+                        device.getVendorId(), device.getProductId());
216 
+                camera = new NikonCamera(connection, listener, new WorkerNotifier(context));
217 
+            }
218 
+
219 
+            return true;
220 
+        }
221 
+
222 
+        if (listener != null) {
223 
+            listener.onError("No compatible camera found");
224 
+        }
225 
+
226 
+        return false;
227 
+    }
228 
+}

+ 34 - 0
app/src/main/java/com/remoteyourcam/usb/ptp/WorkerNotifier.java
Преглед на файла 

@@ -0,0 +1,34 @@
1 
+/**
2 
+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech
3 
+ *
4 
+ * Licensed under the Apache License, Version 2.0 (the "License");
5 
+ * you may not use this file except in compliance with the License.
6 
+ * You may obtain a copy of the License at
7 
+ *
8 
+ *     http://www.apache.org/licenses/LICENSE-2.0
9 
+ *
10 
+ * Unless required by applicable law or agreed to in writing, software
11 
+ * distributed under the License is distributed on an "AS IS" BASIS,
12 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 
+ * See the License for the specific language governing permissions and
14 
+ * limitations under the License.
15 
+ */
16 
+package com.remoteyourcam.usb.ptp;
17 
+
18 
+import android.content.Context;
19 
+
20 
+public class WorkerNotifier implements Camera.WorkerListener {
21 
+
22 
+
23 
+    public WorkerNotifier(Context context) {
24 
+    }
25 
+
26 
+    @Override
27 
+    public void onWorkerStarted() {
28 
+    }
29 
+
30 
+    @Override
31 
+    public void onWorkerEnded() {
32 
+    }
33 
+
34 
+}

+ 61 - 0
app/src/main/java/com/remoteyourcam/usb/ptp/commands/CloseSessionCommand.java
Преглед на файла 

@@ -0,0 +1,61 @@
1 
+/**
2 
+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech
3 
+ *
4 
+ * Licensed under the Apache License, Version 2.0 (the "License");
5 
+ * you may not use this file except in compliance with the License.
6 
+ * You may obtain a copy of the License at
7 
+ *
8 
+ *     http://www.apache.org/licenses/LICENSE-2.0
9 
+ *
10 
+ * Unless required by applicable law or agreed to in writing, software
11 
+ * distributed under the License is distributed on an "AS IS" BASIS,
12 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 
+ * See the License for the specific language governing permissions and
14 
+ * limitations under the License.
15 
+ */
16 
+package com.remoteyourcam.usb.ptp.commands;
17 
+
18 
+import java.nio.ByteBuffer;
19 
+
20 
+import com.remoteyourcam.usb.AppConfig;
21 
+import com.remoteyourcam.usb.ptp.PtpCamera;
22 
+import com.remoteyourcam.usb.ptp.PtpConstants;
23 
+import com.remoteyourcam.usb.ptp.PtpCamera.IO;
24 
+import com.remoteyourcam.usb.ptp.PtpConstants.Operation;
25 
+import com.remoteyourcam.usb.ptp.PtpConstants.Response;
26 
+
27 
+import android.util.Log;
28 
+
29 
+public class CloseSessionCommand extends Command {
30 
+
31 
+    private final String TAG = CloseSessionCommand.class.getSimpleName();
32 
+
33 
+    public CloseSessionCommand(PtpCamera camera) {
34 
+        super(camera);
35 
+    }
36 
+
37 
+    @Override
38 
+    public void exec(IO io) {
39 
+        io.handleCommand(this);
40 
+        // Can this even happen?
41 
+        if (responseCode == Response.DeviceBusy) {
42 
+            camera.onDeviceBusy(this, true);
43 
+            return;
44 
+        }
45 
+        // close even when error happened
46 
+        camera.onSessionClosed();
47 
+        if (responseCode != Response.Ok) {
48 
+            // TODO error report
49 
+            if (AppConfig.LOG) {
50 
+                Log.w(TAG,
51 
+                        String.format("Error response when closing session, response %s",
52 
+                                PtpConstants.responseToString(responseCode)));
53 
+            }
54 
+        }
55 
+    }
56 
+
57 
+    @Override
58 
+    public void encodeCommand(ByteBuffer b) {
59 
+        encodeCommand(b, Operation.CloseSession);
60 
+    }
61 
+}

+ 188 - 0
app/src/main/java/com/remoteyourcam/usb/ptp/commands/Command.java
Преглед на файла 

@@ -0,0 +1,188 @@
1 
+/**
2 
+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech
3 
+ *
4 
+ * Licensed under the Apache License, Version 2.0 (the "License");
5 
+ * you may not use this file except in compliance with the License.
6 
+ * You may obtain a copy of the License at
7 
+ *
8 
+ *     http://www.apache.org/licenses/LICENSE-2.0
9 
+ *
10 
+ * Unless required by applicable law or agreed to in writing, software
11 
+ * distributed under the License is distributed on an "AS IS" BASIS,
12 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 
+ * See the License for the specific language governing permissions and
14 
+ * limitations under the License.
15 
+ */
16 
+package com.remoteyourcam.usb.ptp.commands;
17 
+
18 
+import android.util.Log;
19 
+
20 
+import com.remoteyourcam.usb.AppConfig;
21 
+import com.remoteyourcam.usb.ptp.PacketUtil;
22 
+import com.remoteyourcam.usb.ptp.PtpAction;
23 
+import com.remoteyourcam.usb.ptp.PtpCamera;
24 
+import com.remoteyourcam.usb.ptp.PtpConstants;
25 
+import com.remoteyourcam.usb.ptp.PtpConstants.Type;
26 
+
27 
+import java.nio.ByteBuffer;
28 
+
29 
+/**
30 
+ * Base class for all PTP commands.
31 
+ */
32 
+public abstract class Command implements PtpAction {
33 
+
34 
+    private static final String TAG = "Command";
35 
+
36 
+    protected final PtpCamera camera;
37 
+
38 
+    /**
39 
+     * Deriving classes have to set this field to true if they want to send data
40 
+     * from host to camera.
41 
+     */
42 
+    protected boolean hasDataToSend;
43 
+
44 
+    /**
45 
+     * Received response code, should be handled in
46 
+     * {@link #exec(com.remoteyourcam.usb.ptp.PtpCamera.IO)}.
47 
+     */
48 
+    protected int responseCode;
49 
+
50 
+    private boolean hasResponseReceived;
51 
+
52 
+    public Command(PtpCamera camera) {
53 
+        this.camera = camera;
54 
+    }
55 
+
56 
+    @Override
57 
+    public abstract void exec(PtpCamera.IO io);
58 
+
59 
+    public abstract void encodeCommand(ByteBuffer b);
60 
+
61 
+    /**
62 
+     * Derived classes should implement this method if they want to send data
63 
+     * from host to camera. The field {@code hasDataToSend} has to be set to
64 
+     * true for the sending to be done. The data to send must not be greater
65 
+     * than the USB max packet size, any size below 256 should be save.
66 
+     */
67 
+    public void encodeData(ByteBuffer b) {
68 
+    }
69 
+
70 
+    /**
71 
+     * Derived classes should implement this method if they want to decode data
72 
+     * received in an data packet that has been sent by the camera. The
73 
+     * {@code ByteBuffer} already points to the first byte behind the
74 
+     * transaction id, i.e. the payload.
75 
+     */
76 
+    protected void decodeData(ByteBuffer b, int length) {
77 
+        if (AppConfig.LOG) {
78 
+            Log.w(TAG, "Received data packet but handler not implemented");
79 
+        }
80 
+    }
81 
+
82 
+    /**
83 
+     * Override if any special response data has to be decoded. The
84 
+     * {@code ByteBuffer} already points to the first byte behind the
85 
+     * transaction id, i.e. the payload.
86 
+     */
87 
+    protected void decodeResponse(ByteBuffer b, int length) {
88 
+    }
89 
+
90 
+    public boolean hasDataToSend() {
91 
+        return hasDataToSend;
92 
+    }
93 
+
94 
+    public boolean hasResponseReceived() {
95 
+        return hasResponseReceived;
96 
+    }
97 
+
98 
+    public int getResponseCode() {
99 
+        return responseCode;
100 
+    }
101 
+
102 
+    public void receivedRead(ByteBuffer b) {
103 
+        int length = b.getInt();
104 
+        int type = b.getShort() & 0xFFFF;
105 
+        int code = b.getShort() & 0xFFFF;
106 
+        int tx = b.getInt();
107 
+
108 
+        if (AppConfig.LOG) {
109 
+            Log.i(TAG,
110 
+                    String.format("Received %s packet for %s, length %d, code %s, tx %d",
111 
+                            PtpConstants.typeToString(type), getClass().getSimpleName(), length,
112 
+                            PtpConstants.codeToString(type, code), tx));
113 
+        }
114 
+        if (AppConfig.LOG_PACKETS) {
115 
+            PacketUtil.logHexdump(TAG, b.array(), length < 512 ? length : 512);
116 
+        }
117 
+
118 
+        if (type == Type.Data) {
119 
+            decodeData(b, length);
120 
+        } else if (type == Type.Response) {
121 
+            hasResponseReceived = true;
122 
+            responseCode = code;
123 
+            decodeResponse(b, length);
124 
+        } else {
125 
+            // error
126 
+            hasResponseReceived = true;
127 
+        }
128 
+    }
129 
+
130 
+    /**
131 
+     * Reset fields so this command may be requeued.
132 
+     */
133 
+    @Override
134 
+    public void reset() {
135 
+        responseCode = 0;
136 
+        hasResponseReceived = false;
137 
+    }
138 
+
139 
+    protected void encodeCommand(ByteBuffer b, int code) {
140 
+        b.putInt(12);
141 
+        b.putShort((short) Type.Command);
142 
+        b.putShort((short) code);
143 
+        b.putInt(camera.nextTransactionId());
144 
+        if (AppConfig.LOG_PACKETS) {
145 
+            Log.i(TAG, "command packet for " + getClass().getSimpleName());
146 
+            PacketUtil.logHexdump(TAG, b.array(), 12);
147 
+        }
148 
+    }
149 
+
150 
+    protected void encodeCommand(ByteBuffer b, int code, int p0) {
151 
+        b.putInt(16);
152 
+        b.putShort((short) Type.Command);
153 
+        b.putShort((short) code);
154 
+        b.putInt(camera.nextTransactionId());
155 
+        b.putInt(p0);
156 
+        if (AppConfig.LOG_PACKETS) {
157 
+            Log.i(TAG, "command packet for " + getClass().getSimpleName());
158 
+            PacketUtil.logHexdump(TAG, b.array(), 16);
159 
+        }
160 
+    }
161 
+
162 
+    protected void encodeCommand(ByteBuffer b, int code, int p0, int p1) {
163 
+        b.putInt(20);
164 
+        b.putShort((short) Type.Command);
165 
+        b.putShort((short) code);
166 
+        b.putInt(camera.nextTransactionId());
167 
+        b.putInt(p0);
168 
+        b.putInt(p1);
169 
+        if (AppConfig.LOG_PACKETS) {
170 
+            Log.i(TAG, "command packet for " + getClass().getSimpleName());
171 
+            PacketUtil.logHexdump(TAG, b.array(), 20);
172 
+        }
173 
+    }
174 
+
175 
+    protected void encodeCommand(ByteBuffer b, int code, int p0, int p1, int p2) {
176 
+        b.putInt(24);
177 
+        b.putShort((short) Type.Command);
178 
+        b.putShort((short) code);
179 
+        b.putInt(camera.nextTransactionId());
180 
+        b.putInt(p0);
181 
+        b.putInt(p1);
182 
+        b.putInt(p2);
183 
+        if (AppConfig.LOG_PACKETS) {
184 
+            Log.i(TAG, "command packet for " + getClass().getSimpleName());
185 
+            PacketUtil.logHexdump(TAG, b.array(), 24);
186 
+        }
187 
+    }
188 
+}

+ 62 - 0
app/src/main/java/com/remoteyourcam/usb/ptp/commands/GetDeviceInfoCommand.java
Преглед на файла 

@@ -0,0 +1,62 @@
1 
+/**
2 
+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech
3 
+ *
4 
+ * Licensed under the Apache License, Version 2.0 (the "License");
5 
+ * you may not use this file except in compliance with the License.
6 
+ * You may obtain a copy of the License at
7 
+ *
8 
+ *     http://www.apache.org/licenses/LICENSE-2.0
9 
+ *
10 
+ * Unless required by applicable law or agreed to in writing, software
11 
+ * distributed under the License is distributed on an "AS IS" BASIS,
12 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 
+ * See the License for the specific language governing permissions and
14 
+ * limitations under the License.
15 
+ */
16 
+package com.remoteyourcam.usb.ptp.commands;
17 
+
18 
+import java.nio.ByteBuffer;
19 
+
20 
+import com.remoteyourcam.usb.ptp.PtpCamera;
21 
+import com.remoteyourcam.usb.ptp.PtpConstants;
22 
+import com.remoteyourcam.usb.ptp.PtpCamera.IO;
23 
+import com.remoteyourcam.usb.ptp.PtpConstants.Operation;
24 
+import com.remoteyourcam.usb.ptp.PtpConstants.Response;
25 
+import com.remoteyourcam.usb.ptp.model.DeviceInfo;
26 
+
27 
+public class GetDeviceInfoCommand extends Command {
28 
+
29 
+    private DeviceInfo info;
30 
+
31 
+    public GetDeviceInfoCommand(PtpCamera camera) {
32 
+        super(camera);
33 
+    }
34 
+
35 
+    @Override
36 
+    public void exec(IO io) {
37 
+        io.handleCommand(this);
38 
+        if (responseCode != Response.Ok) {
39 
+            camera.onPtpError(String.format("Couldn't read device information, error code \"%s\"",
40 
+                    PtpConstants.responseToString(responseCode)));
41 
+        } else if (info == null) {
42 
+            camera.onPtpError("Couldn't retrieve device information");
43 
+        }
44 
+    }
45 
+
46 
+    @Override
47 
+    public void reset() {
48 
+        super.reset();
49 
+        info = null;
50 
+    }
51 
+
52 
+    @Override
53 
+    public void encodeCommand(ByteBuffer b) {
54 
+        encodeCommand(b, Operation.GetDeviceInfo);
55 
+    }
56 
+
57 
+    @Override
58 
+    protected void decodeData(ByteBuffer b, int length) {
59 
+        info = new DeviceInfo(b, length);
60 
+        camera.setDeviceInfo(info);
61 
+    }
62 
+}

+ 57 - 0
app/src/main/java/com/remoteyourcam/usb/ptp/commands/GetDevicePropDescCommand.java
Преглед на файла 

@@ -0,0 +1,57 @@
1 
+/**
2 
+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech
3 
+ *
4 
+ * Licensed under the Apache License, Version 2.0 (the "License");
5 
+ * you may not use this file except in compliance with the License.
6 
+ * You may obtain a copy of the License at
7 
+ *
8 
+ *     http://www.apache.org/licenses/LICENSE-2.0
9 
+ *
10 
+ * Unless required by applicable law or agreed to in writing, software
11 
+ * distributed under the License is distributed on an "AS IS" BASIS,
12 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 
+ * See the License for the specific language governing permissions and
14 
+ * limitations under the License.
15 
+ */
16 
+package com.remoteyourcam.usb.ptp.commands;
17 
+
18 
+import java.nio.ByteBuffer;
19 
+
20 
+import com.remoteyourcam.usb.ptp.PtpCamera;
21 
+import com.remoteyourcam.usb.ptp.PtpCamera.IO;
22 
+import com.remoteyourcam.usb.ptp.PtpConstants;
23 
+import com.remoteyourcam.usb.ptp.model.DevicePropDesc;
24 
+
25 
+public class GetDevicePropDescCommand extends Command {
26 
+
27 
+    private final int property;
28 
+    private DevicePropDesc devicePropDesc;
29 
+
30 
+    public GetDevicePropDescCommand(PtpCamera camera, int property) {
31 
+        super(camera);
32 
+        this.property = property;
33 
+    }
34 
+
35 
+    @Override
36 
+    public void exec(IO io) {
37 
+        io.handleCommand(this);
38 
+        if (responseCode == PtpConstants.Response.DeviceBusy) {
39 
+            camera.onDeviceBusy(this, true);
40 
+        }
41 
+        if (devicePropDesc != null) {
42 
+            // this order is important
43 
+            camera.onPropertyDescChanged(property, devicePropDesc);
44 
+            camera.onPropertyChanged(property, devicePropDesc.currentValue);
45 
+        }
46 
+    }
47 
+
48 
+    @Override
49 
+    public void encodeCommand(ByteBuffer b) {
50 
+        encodeCommand(b, PtpConstants.Operation.GetDevicePropDesc, property);
51 
+    }
52 
+
53 
+    @Override
54 
+    protected void decodeData(ByteBuffer b, int length) {
55 
+        devicePropDesc = new DevicePropDesc(b, length);
56 
+    }
57 
+}

+ 68 - 0
app/src/main/java/com/remoteyourcam/usb/ptp/commands/GetDevicePropValueCommand.java
Преглед на файла 

@@ -0,0 +1,68 @@
1 
+/**
2 
+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech
3 
+ *
4 
+ * Licensed under the Apache License, Version 2.0 (the "License");
5 
+ * you may not use this file except in compliance with the License.
6 
+ * You may obtain a copy of the License at
7 
+ *
8 
+ *     http://www.apache.org/licenses/LICENSE-2.0
9 
+ *
10 
+ * Unless required by applicable law or agreed to in writing, software
11 
+ * distributed under the License is distributed on an "AS IS" BASIS,
12 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 
+ * See the License for the specific language governing permissions and
14 
+ * limitations under the License.
15 
+ */
16 
+package com.remoteyourcam.usb.ptp.commands;
17 
+
18 
+import java.nio.ByteBuffer;
19 
+
20 
+import com.remoteyourcam.usb.ptp.PtpCamera;
21 
+import com.remoteyourcam.usb.ptp.PtpCamera.IO;
22 
+import com.remoteyourcam.usb.ptp.PtpConstants;
23 
+import com.remoteyourcam.usb.ptp.PtpConstants.Datatype;
24 
+import com.remoteyourcam.usb.ptp.PtpConstants.Response;
25 
+
26 
+public class GetDevicePropValueCommand extends Command {
27 
+
28 
+    private final int property;
29 
+    private final int datatype;
30 
+    private int value;
31 
+
32 
+    public GetDevicePropValueCommand(PtpCamera camera, int property, int datatype) {
33 
+        super(camera);
34 
+        this.property = property;
35 
+        this.datatype = datatype;
36 
+    }
37 
+
38 
+    @Override
39 
+    public void exec(IO io) {
40 
+        io.handleCommand(this);
41 
+        if (responseCode == Response.DeviceBusy) {
42 
+            camera.onDeviceBusy(this, true);
43 
+        }
44 
+        if (responseCode == Response.Ok) {
45 
+            camera.onPropertyChanged(property, value);
46 
+        }
47 
+    }
48 
+
49 
+    @Override
50 
+    public void encodeCommand(ByteBuffer b) {
51 
+        encodeCommand(b, PtpConstants.Operation.GetDevicePropValue, property);
52 
+    }
53 
+
54 
+    @Override
55 
+    protected void decodeData(ByteBuffer b, int length) {
56 
+        if (datatype == Datatype.int8) {
57 
+            value = b.get();
58 
+        } else if (datatype == Datatype.uint8) {
59 
+            value = b.get() & 0xFF;
60 
+        } else if (datatype == Datatype.uint16) {
61 
+            value = b.getShort() & 0xFFFF;
62 
+        } else if (datatype == Datatype.int16) {
63 
+            value = b.getShort();
64 
+        } else if (datatype == Datatype.int32 || datatype == Datatype.uint32) {
65 
+            value = b.getInt();
66 
+        }
67 
+    }
68 
+}

+ 90 - 0
app/src/main/java/com/remoteyourcam/usb/ptp/commands/GetObjectCommand.java
Преглед на файла 

@@ -0,0 +1,90 @@
1 
+/**
2 
+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech
3 
+ *
4 
+ * Licensed under the Apache License, Version 2.0 (the "License");
5 
+ * you may not use this file except in compliance with the License.
6 
+ * You may obtain a copy of the License at
7 
+ *
8 
+ *     http://www.apache.org/licenses/LICENSE-2.0
9 
+ *
10 
+ * Unless required by applicable law or agreed to in writing, software
11 
+ * distributed under the License is distributed on an "AS IS" BASIS,
12 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 
+ * See the License for the specific language governing permissions and
14 
+ * limitations under the License.
15 
+ */
16 
+package com.remoteyourcam.usb.ptp.commands;
17 
+
18 
+import java.nio.ByteBuffer;
19 
+
20 
+import android.graphics.Bitmap;
21 
+import android.graphics.BitmapFactory;
22 
+import android.util.Log;
23 
+
24 
+import com.remoteyourcam.usb.ptp.PtpCamera;
25 
+import com.remoteyourcam.usb.ptp.PtpCamera.IO;
26 
+import com.remoteyourcam.usb.ptp.PtpConstants;
27 
+
28 
+/**
29 
+ * Read file data from camera with specified {@code objectHandle}.
30 
+ */
31 
+public class GetObjectCommand extends Command {
32 
+
33 
+    private static final String TAG = GetObjectCommand.class.getSimpleName();
34 
+
35 
+    private final int objectHandle;
36 
+
37 
+    private final BitmapFactory.Options options;
38 
+    private Bitmap inBitmap;
39 
+
40 
+    private boolean outOfMemoryError;
41 
+
42 
+    public GetObjectCommand(PtpCamera camera, int objectHandle, int sampleSize) {
43 
+        super(camera);
44 
+        this.objectHandle = objectHandle;
45 
+        options = new BitmapFactory.Options();
46 
+        if (sampleSize >= 1 && sampleSize <= 4) {
47 
+            options.inSampleSize = sampleSize;
48 
+        } else {
49 
+            options.inSampleSize = 2;
50 
+        }
51 
+    }
52 
+
53 
+    public Bitmap getBitmap() {
54 
+        return inBitmap;
55 
+    }
56 
+
57 
+    public boolean isOutOfMemoryError() {
58 
+        return outOfMemoryError;
59 
+    }
60 
+
61 
+    @Override
62 
+    public void exec(IO io) {
63 
+        throw new UnsupportedOperationException();
64 
+    }
65 
+
66 
+    @Override
67 
+    public void reset() {
68 
+        super.reset();
69 
+        inBitmap = null;
70 
+        outOfMemoryError = false;
71 
+    }
72 
+
73 
+    @Override
74 
+    public void encodeCommand(ByteBuffer b) {
75 
+        encodeCommand(b, PtpConstants.Operation.GetObject, objectHandle);
76 
+    }
77 
+
78 
+    @Override
79 
+    protected void decodeData(ByteBuffer b, int length) {
80 
+        try {
81 
+            // 12 == offset of data header
82 
+            inBitmap = BitmapFactory.decodeByteArray(b.array(), 12, length - 12, options);
83 
+        } catch (RuntimeException e) {
84 
+            Log.i(TAG, "exception on decoding picture : " + e.toString());
85 
+        } catch (OutOfMemoryError e) {
86 
+            System.gc();
87 
+            outOfMemoryError = true;
88 
+        }
89 
+    }
90 
+}

+ 79 - 0
app/src/main/java/com/remoteyourcam/usb/ptp/commands/GetObjectHandlesCommand.java
Преглед на файла 

@@ -0,0 +1,79 @@
1 
+/**
2 
+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech
3 
+ *
4 
+ * Licensed under the Apache License, Version 2.0 (the "License");
5 
+ * you may not use this file except in compliance with the License.
6 
+ * You may obtain a copy of the License at
7 
+ *
8 
+ *     http://www.apache.org/licenses/LICENSE-2.0
9 
+ *
10 
+ * Unless required by applicable law or agreed to in writing, software
11 
+ * distributed under the License is distributed on an "AS IS" BASIS,
12 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 
+ * See the License for the specific language governing permissions and
14 
+ * limitations under the License.
15 
+ */
16 
+package com.remoteyourcam.usb.ptp.commands;
17 
+
18 
+import java.nio.ByteBuffer;
19 
+
20 
+import com.remoteyourcam.usb.ptp.Camera.StorageInfoListener;
21 
+import com.remoteyourcam.usb.ptp.PacketUtil;
22 
+import com.remoteyourcam.usb.ptp.PtpCamera;
23 
+import com.remoteyourcam.usb.ptp.PtpCamera.IO;
24 
+import com.remoteyourcam.usb.ptp.PtpConstants;
25 
+import com.remoteyourcam.usb.ptp.PtpConstants.Response;
26 
+
27 
+public class GetObjectHandlesCommand extends Command {
28 
+
29 
+    private final int storageId;
30 
+    private final int objectFormat;
31 
+    private final int associationHandle;
32 
+    private int[] objectHandles;
33 
+    private final StorageInfoListener listener;
34 
+
35 
+    public int[] getObjectHandles() {
36 
+        if (objectHandles == null) {
37 
+            return new int[0];
38 
+        }
39 
+        return objectHandles;
40 
+    }
41 
+
42 
+    public GetObjectHandlesCommand(PtpCamera camera, StorageInfoListener listener, int storageId) {
43 
+        this(camera, listener, storageId, 0, 0);
44 
+    }
45 
+
46 
+    public GetObjectHandlesCommand(PtpCamera camera, StorageInfoListener listener, int storageId, int objectFormat) {
47 
+        this(camera, listener, storageId, objectFormat, 0);
48 
+    }
49 
+
50 
+    public GetObjectHandlesCommand(PtpCamera camera, StorageInfoListener listener, int storageId, int objectFormat,
51 
+            int associationHandle) {
52 
+        super(camera);
53 
+        this.listener = listener;
54 
+        this.storageId = storageId;
55 
+        this.objectFormat = objectFormat;
56 
+        this.associationHandle = associationHandle;
57 
+    }
58 
+
59 
+    @Override
60 
+    public void exec(IO io) {
61 
+        io.handleCommand(this);
62 
+        if (getResponseCode() != Response.Ok) {
63 
+            // error
64 
+            listener.onImageHandlesRetrieved(new int[0]);
65 
+            return;
66 
+        }
67 
+        listener.onImageHandlesRetrieved(objectHandles);
68 
+    }
69 
+
70 
+    @Override
71 
+    public void encodeCommand(ByteBuffer b) {
72 
+        super.encodeCommand(b, PtpConstants.Operation.GetObjectHandles, storageId, objectFormat, associationHandle);
73 
+    }
74 
+
75 
+    @Override
76 
+    protected void decodeData(ByteBuffer b, int length) {
77 
+        objectHandles = PacketUtil.readU32Array(b);
78 
+    }
79 
+}

+ 73 - 0
app/src/main/java/com/remoteyourcam/usb/ptp/commands/GetObjectInfoCommand.java
Преглед на файла 

@@ -0,0 +1,73 @@
1 
+/**
2 
+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech
3 
+ *
4 
+ * Licensed under the Apache License, Version 2.0 (the "License");
5 
+ * you may not use this file except in compliance with the License.
6 
+ * You may obtain a copy of the License at
7 
+ *
8 
+ *     http://www.apache.org/licenses/LICENSE-2.0
9 
+ *
10 
+ * Unless required by applicable law or agreed to in writing, software
11 
+ * distributed under the License is distributed on an "AS IS" BASIS,
12 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 
+ * See the License for the specific language governing permissions and
14 
+ * limitations under the License.
15 
+ */
16 
+package com.remoteyourcam.usb.ptp.commands;
17 
+
18 
+import java.nio.ByteBuffer;
19 
+
20 
+import com.remoteyourcam.usb.AppConfig;
21 
+import com.remoteyourcam.usb.ptp.PtpCamera;
22 
+import com.remoteyourcam.usb.ptp.PtpConstants;
23 
+import com.remoteyourcam.usb.ptp.PtpCamera.IO;
24 
+import com.remoteyourcam.usb.ptp.PtpConstants.Response;
25 
+import com.remoteyourcam.usb.ptp.model.ObjectInfo;
26 
+
27 
+import android.util.Log;
28 
+
29 
+public class GetObjectInfoCommand extends Command {
30 
+
31 
+    private final String TAG = GetObjectInfoCommand.class.getSimpleName();
32 
+
33 
+    private final int outObjectHandle;
34 
+    private ObjectInfo inObjectInfo;
35 
+
36 
+    public GetObjectInfoCommand(PtpCamera camera, int objectHandle) {
37 
+        super(camera);
38 
+        this.outObjectHandle = objectHandle;
39 
+    }
40 
+
41 
+    public ObjectInfo getObjectInfo() {
42 
+        return inObjectInfo;
43 
+    }
44 
+
45 
+    @Override
46 
+    public void exec(IO io) {
47 
+        io.handleCommand(this);
48 
+        if (responseCode == Response.DeviceBusy) {
49 
+            camera.onDeviceBusy(this, true);
50 
+        }
51 
+        if (inObjectInfo != null) {
52 
+            if (AppConfig.LOG) {
53 
+                Log.i(TAG, inObjectInfo.toString());
54 
+            }
55 
+        }
56 
+    }
57 
+
58 
+    @Override
59 
+    public void reset() {
60 
+        super.reset();
61 
+        inObjectInfo = null;
62 
+    }
63 
+
64 
+    @Override
65 
+    public void encodeCommand(ByteBuffer b) {
66 
+        encodeCommand(b, PtpConstants.Operation.GetObjectInfo, outObjectHandle);
67 
+    }
68 
+
69 
+    @Override
70 
+    protected void decodeData(ByteBuffer b, int length) {
71 
+        inObjectInfo = new ObjectInfo(b, length);
72 
+    }
73 
+}

+ 54 - 0
app/src/main/java/com/remoteyourcam/usb/ptp/commands/GetStorageIdsCommand.java
Преглед на файла 

@@ -0,0 +1,54 @@
1 
+/**
2 
+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech
3 
+ *
4 
+ * Licensed under the Apache License, Version 2.0 (the "License");
5 
+ * you may not use this file except in compliance with the License.
6 
+ * You may obtain a copy of the License at
7 
+ *
8 
+ *     http://www.apache.org/licenses/LICENSE-2.0
9 
+ *
10 
+ * Unless required by applicable law or agreed to in writing, software
11 
+ * distributed under the License is distributed on an "AS IS" BASIS,
12 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 
+ * See the License for the specific language governing permissions and
14 
+ * limitations under the License.
15 
+ */
16 
+package com.remoteyourcam.usb.ptp.commands;
17 
+
18 
+import java.nio.ByteBuffer;
19 
+
20 
+import com.remoteyourcam.usb.ptp.PacketUtil;
21 
+import com.remoteyourcam.usb.ptp.PtpCamera;
22 
+import com.remoteyourcam.usb.ptp.PtpCamera.IO;
23 
+import com.remoteyourcam.usb.ptp.PtpConstants;
24 
+
25 
+public class GetStorageIdsCommand extends Command {
26 
+
27 
+    private int[] storageIds;
28 
+
29 
+    public int[] getStorageIds() {
30 
+        if (storageIds == null) {
31 
+            return new int[0];
32 
+        }
33 
+        return storageIds;
34 
+    }
35 
+
36 
+    public GetStorageIdsCommand(PtpCamera camera) {
37 
+        super(camera);
38 
+    }
39 
+
40 
+    @Override
41 
+    public void exec(IO io) {
42 
+        io.handleCommand(this);
43 
+    }
44 
+
45 
+    @Override
46 
+    public void encodeCommand(ByteBuffer b) {
47 
+        super.encodeCommand(b, PtpConstants.Operation.GetStorageIDs);
48 
+    }
49 
+
50 
+    @Override
51 
+    protected void decodeData(ByteBuffer b, int length) {
52 
+        storageIds = PacketUtil.readU32Array(b);
53 
+    }
54 
+}

+ 53 - 0
app/src/main/java/com/remoteyourcam/usb/ptp/commands/GetStorageInfoCommand.java
Преглед на файла 

@@ -0,0 +1,53 @@
1 
+/**
2 
+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech
3 
+ *
4 
+ * Licensed under the Apache License, Version 2.0 (the "License");
5 
+ * you may not use this file except in compliance with the License.
6 
+ * You may obtain a copy of the License at
7 
+ *
8 
+ *     http://www.apache.org/licenses/LICENSE-2.0
9 
+ *
10 
+ * Unless required by applicable law or agreed to in writing, software
11 
+ * distributed under the License is distributed on an "AS IS" BASIS,
12 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 
+ * See the License for the specific language governing permissions and
14 
+ * limitations under the License.
15 
+ */
16 
+package com.remoteyourcam.usb.ptp.commands;
17 
+
18 
+import java.nio.ByteBuffer;
19 
+
20 
+import com.remoteyourcam.usb.ptp.PtpCamera;
21 
+import com.remoteyourcam.usb.ptp.PtpCamera.IO;
22 
+import com.remoteyourcam.usb.ptp.PtpConstants;
23 
+import com.remoteyourcam.usb.ptp.model.StorageInfo;
24 
+
25 
+public class GetStorageInfoCommand extends Command {
26 
+
27 
+    private StorageInfo storageInfo;
28 
+    private final int storageId;
29 
+
30 
+    public StorageInfo getStorageInfo() {
31 
+        return storageInfo;
32 
+    }
33 
+
34 
+    public GetStorageInfoCommand(PtpCamera camera, int storageId) {
35 
+        super(camera);
36 
+        this.storageId = storageId;
37 
+    }
38 
+
39 
+    @Override
40 
+    public void exec(IO io) {
41 
+        io.handleCommand(this);
42 
+    }
43 
+
44 
+    @Override
45 
+    public void encodeCommand(ByteBuffer b) {
46 
+        super.encodeCommand(b, PtpConstants.Operation.GetStorageInfo, storageId);
47 
+    }
48 
+
49 
+    @Override
50 
+    protected void decodeData(ByteBuffer b, int length) {
51 
+        storageInfo = new StorageInfo(b, length);
52 
+    }
53 
+}

+ 70 - 0
app/src/main/java/com/remoteyourcam/usb/ptp/commands/GetStorageInfosAction.java
Преглед на файла 

@@ -0,0 +1,70 @@
1 
+/**
2 
+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech
3 
+ *
4 
+ * Licensed under the Apache License, Version 2.0 (the "License");
5 
+ * you may not use this file except in compliance with the License.
6 
+ * You may obtain a copy of the License at
7 
+ *
8 
+ *     http://www.apache.org/licenses/LICENSE-2.0
9 
+ *
10 
+ * Unless required by applicable law or agreed to in writing, software
11 
+ * distributed under the License is distributed on an "AS IS" BASIS,
12 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 
+ * See the License for the specific language governing permissions and
14 
+ * limitations under the License.
15 
+ */
16 
+package com.remoteyourcam.usb.ptp.commands;
17 
+
18 
+import com.remoteyourcam.usb.ptp.Camera;
19 
+import com.remoteyourcam.usb.ptp.Camera.StorageInfoListener;
20 
+import com.remoteyourcam.usb.ptp.PtpAction;
21 
+import com.remoteyourcam.usb.ptp.PtpCamera;
22 
+import com.remoteyourcam.usb.ptp.PtpCamera.IO;
23 
+import com.remoteyourcam.usb.ptp.PtpConstants.Response;
24 
+
25 
+public class GetStorageInfosAction implements PtpAction {
26 
+
27 
+    private final PtpCamera camera;
28 
+    private final StorageInfoListener listener;
29 
+
30 
+    public GetStorageInfosAction(PtpCamera camera, Camera.StorageInfoListener listener) {
31 
+        this.camera = camera;
32 
+        this.listener = listener;
33 
+    }
34 
+
35 
+    @Override
36 
+    public void exec(IO io) {
37 
+        GetStorageIdsCommand getStorageIds = new GetStorageIdsCommand(camera);
38 
+        io.handleCommand(getStorageIds);
39 
+
40 
+        if (getStorageIds.getResponseCode() != Response.Ok) {
41 
+            listener.onAllStoragesFound();
42 
+            return;
43 
+        }
44 
+
45 
+        int ids[] = getStorageIds.getStorageIds();
46 
+        for (int i = 0; i < ids.length; ++i) {
47 
+            int storageId = ids[i];
48 
+            GetStorageInfoCommand c = new GetStorageInfoCommand(camera, storageId);
49 
+            io.handleCommand(c);
50 
+
51 
+            if (c.getResponseCode() != Response.Ok) {
52 
+                listener.onAllStoragesFound();
53 
+                return;
54 
+            }
55 
+
56 
+            String label = c.getStorageInfo().volumeLabel.isEmpty() ? c.getStorageInfo().storageDescription : c
57 
+                    .getStorageInfo().volumeLabel;
58 
+            if (label == null || label.isEmpty()) {
59 
+                label = "Storage " + i;
60 
+            }
61 
+            listener.onStorageFound(storageId, label);
62 
+        }
63 
+
64 
+        listener.onAllStoragesFound();
65 
+    }
66 
+
67 
+    @Override
68 
+    public void reset() {
69 
+    }
70 
+}

+ 71 - 0
app/src/main/java/com/remoteyourcam/usb/ptp/commands/GetThumb.java
Преглед на файла 

@@ -0,0 +1,71 @@
1 
+/**
2 
+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech
3 
+ *
4 
+ * Licensed under the Apache License, Version 2.0 (the "License");
5 
+ * you may not use this file except in compliance with the License.
6 
+ * You may obtain a copy of the License at
7 
+ *
8 
+ *     http://www.apache.org/licenses/LICENSE-2.0
9 
+ *
10 
+ * Unless required by applicable law or agreed to in writing, software
11 
+ * distributed under the License is distributed on an "AS IS" BASIS,
12 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 
+ * See the License for the specific language governing permissions and
14 
+ * limitations under the License.
15 
+ */
16 
+package com.remoteyourcam.usb.ptp.commands;
17 
+
18 
+import java.nio.ByteBuffer;
19 
+
20 
+import android.graphics.Bitmap;
21 
+import android.graphics.BitmapFactory;
22 
+import android.util.Log;
23 
+
24 
+import com.remoteyourcam.usb.ptp.PtpCamera;
25 
+import com.remoteyourcam.usb.ptp.PtpCamera.IO;
26 
+import com.remoteyourcam.usb.ptp.PtpConstants;
27 
+
28 
+public class GetThumb extends Command {
29 
+
30 
+    private static final String TAG = GetThumb.class.getSimpleName();
31 
+
32 
+    private final int objectHandle;
33 
+    private Bitmap inBitmap;
34 
+
35 
+    public GetThumb(PtpCamera camera, int objectHandle) {
36 
+        super(camera);
37 
+        this.objectHandle = objectHandle;
38 
+    }
39 
+
40 
+    public Bitmap getBitmap() {
41 
+        return inBitmap;
42 
+    }
43 
+
44 
+    @Override
45 
+    public void exec(IO io) {
46 
+        throw new UnsupportedOperationException();
47 
+    }
48 
+
49 
+    @Override
50 
+    public void reset() {
51 
+        super.reset();
52 
+        inBitmap = null;
53 
+    }
54 
+
55 
+    @Override
56 
+    public void encodeCommand(ByteBuffer b) {
57 
+        encodeCommand(b, PtpConstants.Operation.GetThumb, objectHandle);
58 
+    }
59 
+
60 
+    @Override
61 
+    protected void decodeData(ByteBuffer b, int length) {
62 
+        try {
63 
+            // 12 == offset of data header
64 
+            inBitmap = BitmapFactory.decodeByteArray(b.array(), 12, length - 12);
65 
+        } catch (RuntimeException e) {
66 
+            Log.i(TAG, "exception on decoding picture : " + e.toString());
67 
+        } catch (OutOfMemoryError e) {
68 
+            System.gc();
69 
+        }
70 
+    }
71 
+}

+ 44 - 0
app/src/main/java/com/remoteyourcam/usb/ptp/commands/InitiateCaptureCommand.java
Преглед на файла 

@@ -0,0 +1,44 @@
1 
+/**
2 
+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech
3 
+ *
4 
+ * Licensed under the Apache License, Version 2.0 (the "License");
5 
+ * you may not use this file except in compliance with the License.
6 
+ * You may obtain a copy of the License at
7 
+ *
8 
+ *     http://www.apache.org/licenses/LICENSE-2.0
9 
+ *
10 
+ * Unless required by applicable law or agreed to in writing, software
11 
+ * distributed under the License is distributed on an "AS IS" BASIS,
12 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 
+ * See the License for the specific language governing permissions and
14 
+ * limitations under the License.
15 
+ */
16 
+package com.remoteyourcam.usb.ptp.commands;
17 
+
18 
+import java.nio.ByteBuffer;
19 
+
20 
+import com.remoteyourcam.usb.ptp.PtpCamera;
21 
+import com.remoteyourcam.usb.ptp.PtpCamera.IO;
22 
+import com.remoteyourcam.usb.ptp.PtpConstants.Operation;
23 
+import com.remoteyourcam.usb.ptp.PtpConstants.Response;
24 
+
25 
+public class InitiateCaptureCommand extends Command {
26 
+
27 
+    public InitiateCaptureCommand(PtpCamera camera) {
28 
+        super(camera);
29 
+    }
30 
+
31 
+    @Override
32 
+    public void exec(IO io) {
33 
+        io.handleCommand(this);
34 
+        if (responseCode == Response.DeviceBusy) {
35 
+            camera.onDeviceBusy(this, true); // TODO when nikon live view is enabled this stalls
36 
+            return;
37 
+        }
38 
+    }
39 
+
40 
+    @Override
41 
+    public void encodeCommand(ByteBuffer b) {
42 
+        encodeCommand(b, Operation.InitiateCapture, 0, 0);
43 
+    }
44 
+}

+ 48 - 0
app/src/main/java/com/remoteyourcam/usb/ptp/commands/OpenSessionCommand.java
Преглед на файла 

@@ -0,0 +1,48 @@
1 
+/**
2 
+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech
3 
+ *
4 
+ * Licensed under the Apache License, Version 2.0 (the "License");
5 
+ * you may not use this file except in compliance with the License.
6 
+ * You may obtain a copy of the License at
7 
+ *
8 
+ *     http://www.apache.org/licenses/LICENSE-2.0
9 
+ *
10 
+ * Unless required by applicable law or agreed to in writing, software
11 
+ * distributed under the License is distributed on an "AS IS" BASIS,
12 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 
+ * See the License for the specific language governing permissions and
14 
+ * limitations under the License.
15 
+ */
16 
+package com.remoteyourcam.usb.ptp.commands;
17 
+
18 
+import java.nio.ByteBuffer;
19 
+
20 
+import com.remoteyourcam.usb.ptp.PtpCamera;
21 
+import com.remoteyourcam.usb.ptp.PtpConstants;
22 
+import com.remoteyourcam.usb.ptp.PtpCamera.IO;
23 
+import com.remoteyourcam.usb.ptp.PtpConstants.Operation;
24 
+import com.remoteyourcam.usb.ptp.PtpConstants.Response;
25 
+
26 
+public class OpenSessionCommand extends Command {
27 
+
28 
+    public OpenSessionCommand(PtpCamera camera) {
29 
+        super(camera);
30 
+    }
31 
+
32 
+    @Override
33 
+    public void exec(IO io) {
34 
+        io.handleCommand(this);
35 
+        if (responseCode == Response.Ok) {
36 
+            camera.onSessionOpened();
37 
+        } else {
38 
+            camera.onPtpError(String.format("Couldn't open session, error code \"%s\"",
39 
+                    PtpConstants.responseToString(responseCode)));
40 
+        }
41 
+    }
42 
+
43 
+    @Override
44 
+    public void encodeCommand(ByteBuffer b) {
45 
+        camera.resetTransactionId();
46 
+        encodeCommand(b, Operation.OpenSession, 1);
47 
+    }
48 
+}

+ 51 - 0
app/src/main/java/com/remoteyourcam/usb/ptp/commands/RetrieveAddedObjectInfoAction.java
Преглед на файла 

@@ -0,0 +1,51 @@
1 
+/**
2 
+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech
3 
+ *
4 
+ * Licensed under the Apache License, Version 2.0 (the "License");
5 
+ * you may not use this file except in compliance with the License.
6 
+ * You may obtain a copy of the License at
7 
+ *
8 
+ *     http://www.apache.org/licenses/LICENSE-2.0
9 
+ *
10 
+ * Unless required by applicable law or agreed to in writing, software
11 
+ * distributed under the License is distributed on an "AS IS" BASIS,
12 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 
+ * See the License for the specific language governing permissions and
14 
+ * limitations under the License.
15 
+ */
16 
+package com.remoteyourcam.usb.ptp.commands;
17 
+
18 
+import com.remoteyourcam.usb.ptp.PtpAction;
19 
+import com.remoteyourcam.usb.ptp.PtpCamera;
20 
+import com.remoteyourcam.usb.ptp.PtpCamera.IO;
21 
+import com.remoteyourcam.usb.ptp.PtpConstants.Response;
22 
+
23 
+public class RetrieveAddedObjectInfoAction implements PtpAction {
24 
+
25 
+    private final PtpCamera camera;
26 
+    private final int objectHandle;
27 
+
28 
+    public RetrieveAddedObjectInfoAction(PtpCamera camera, int objectHandle) {
29 
+        this.camera = camera;
30 
+        this.objectHandle = objectHandle;
31 
+    }
32 
+
33 
+    @Override
34 
+    public void exec(IO io) {
35 
+        GetObjectInfoCommand getInfo = new GetObjectInfoCommand(camera, objectHandle);
36 
+        io.handleCommand(getInfo);
37 
+
38 
+        if (getInfo.getResponseCode() != Response.Ok) {
39 
+            return;
40 
+        }
41 
+        if (getInfo.getObjectInfo() == null) {
42 
+            return;
43 
+        }
44 
+
45 
+        camera.onEventObjectAdded(objectHandle, getInfo.getObjectInfo().objectFormat);
46 
+    }
47 
+
48 
+    @Override
49 
+    public void reset() {
50 
+    }
51 
+}

+ 54 - 0
app/src/main/java/com/remoteyourcam/usb/ptp/commands/RetrieveImageAction.java
Преглед на файла 

@@ -0,0 +1,54 @@
1 
+/**
2 
+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech
3 
+ *
4 
+ * Licensed under the Apache License, Version 2.0 (the "License");
5 
+ * you may not use this file except in compliance with the License.
6 
+ * You may obtain a copy of the License at
7 
+ *
8 
+ *     http://www.apache.org/licenses/LICENSE-2.0
9 
+ *
10 
+ * Unless required by applicable law or agreed to in writing, software
11 
+ * distributed under the License is distributed on an "AS IS" BASIS,
12 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 
+ * See the License for the specific language governing permissions and
14 
+ * limitations under the License.
15 
+ */
16 
+package com.remoteyourcam.usb.ptp.commands;
17 
+
18 
+import com.remoteyourcam.usb.ptp.Camera.RetrieveImageListener;
19 
+import com.remoteyourcam.usb.ptp.PtpAction;
20 
+import com.remoteyourcam.usb.ptp.PtpCamera;
21 
+import com.remoteyourcam.usb.ptp.PtpCamera.IO;
22 
+import com.remoteyourcam.usb.ptp.PtpConstants.Response;
23 
+
24 
+public class RetrieveImageAction implements PtpAction {
25 
+
26 
+    private final PtpCamera camera;
27 
+    private final int objectHandle;
28 
+    private final RetrieveImageListener listener;
29 
+    private final int sampleSize;
30 
+
31 
+    public RetrieveImageAction(PtpCamera camera, RetrieveImageListener listener, int objectHandle, int sampleSize) {
32 
+        this.camera = camera;
33 
+        this.listener = listener;
34 
+        this.objectHandle = objectHandle;
35 
+        this.sampleSize = sampleSize;
36 
+    }
37 
+
38 
+    @Override
39 
+    public void exec(IO io) {
40 
+        GetObjectCommand getObject = new GetObjectCommand(camera, objectHandle, sampleSize);
41 
+        io.handleCommand(getObject);
42 
+
43 
+        if (getObject.getResponseCode() != Response.Ok || getObject.getBitmap() == null) {
44 
+            listener.onImageRetrieved(0, null);
45 
+            return;
46 
+        }
47 
+
48 
+        listener.onImageRetrieved(objectHandle, getObject.getBitmap());
49 
+    }
50 
+
51 
+    @Override
52 
+    public void reset() {
53 
+    }
54 
+}

+ 70 - 0
app/src/main/java/com/remoteyourcam/usb/ptp/commands/RetrieveImageInfoAction.java
Преглед на файла 

@@ -0,0 +1,70 @@
1 
+/**
2 
+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech
3 
+ *
4 
+ * Licensed under the Apache License, Version 2.0 (the "License");
5 
+ * you may not use this file except in compliance with the License.
6 
+ * You may obtain a copy of the License at
7 
+ *
8 
+ *     http://www.apache.org/licenses/LICENSE-2.0
9 
+ *
10 
+ * Unless required by applicable law or agreed to in writing, software
11 
+ * distributed under the License is distributed on an "AS IS" BASIS,
12 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 
+ * See the License for the specific language governing permissions and
14 
+ * limitations under the License.
15 
+ */
16 
+package com.remoteyourcam.usb.ptp.commands;
17 
+
18 
+import android.graphics.Bitmap;
19 
+
20 
+import com.remoteyourcam.usb.ptp.Camera.RetrieveImageInfoListener;
21 
+import com.remoteyourcam.usb.ptp.PtpAction;
22 
+import com.remoteyourcam.usb.ptp.PtpCamera;
23 
+import com.remoteyourcam.usb.ptp.PtpCamera.IO;
24 
+import com.remoteyourcam.usb.ptp.PtpConstants;
25 
+import com.remoteyourcam.usb.ptp.PtpConstants.Response;
26 
+import com.remoteyourcam.usb.ptp.model.ObjectInfo;
27 
+
28 
+public class RetrieveImageInfoAction implements PtpAction {
29 
+
30 
+    private final PtpCamera camera;
31 
+    private final int objectHandle;
32 
+    private final RetrieveImageInfoListener listener;
33 
+
34 
+    public RetrieveImageInfoAction(PtpCamera camera, RetrieveImageInfoListener listener, int objectHandle) {
35 
+        this.camera = camera;
36 
+        this.listener = listener;
37 
+        this.objectHandle = objectHandle;
38 
+    }
39 
+
40 
+    @Override
41 
+    public void exec(IO io) {
42 
+        GetObjectInfoCommand getInfo = new GetObjectInfoCommand(camera, objectHandle);
43 
+        io.handleCommand(getInfo);
44 
+
45 
+        if (getInfo.getResponseCode() != Response.Ok) {
46 
+            return;
47 
+        }
48 
+
49 
+        ObjectInfo objectInfo = getInfo.getObjectInfo();
50 
+        if (objectInfo == null) {
51 
+            return;
52 
+        }
53 
+
54 
+        Bitmap thumbnail = null;
55 
+        if (objectInfo.thumbFormat == PtpConstants.ObjectFormat.JFIF
56 
+                || objectInfo.thumbFormat == PtpConstants.ObjectFormat.EXIF_JPEG) {
57 
+            GetThumb getThumb = new GetThumb(camera, objectHandle);
58 
+            io.handleCommand(getThumb);
59 
+            if (getThumb.getResponseCode() == Response.Ok) {
60 
+                thumbnail = getThumb.getBitmap();
61 
+            }
62 
+        }
63 
+
64 
+        listener.onImageInfoRetrieved(objectHandle, getInfo.getObjectInfo(), thumbnail);
65 
+    }
66 
+
67 
+    @Override
68 
+    public void reset() {
69 
+    }
70 
+}

+ 86 - 0
app/src/main/java/com/remoteyourcam/usb/ptp/commands/RetrievePictureAction.java
Преглед на файла 

@@ -0,0 +1,86 @@
1 
+/**
2 
+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech
3 
+ *
4 
+ * Licensed under the Apache License, Version 2.0 (the "License");
5 
+ * you may not use this file except in compliance with the License.
6 
+ * You may obtain a copy of the License at
7 
+ *
8 
+ *     http://www.apache.org/licenses/LICENSE-2.0
9 
+ *
10 
+ * Unless required by applicable law or agreed to in writing, software
11 
+ * distributed under the License is distributed on an "AS IS" BASIS,
12 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 
+ * See the License for the specific language governing permissions and
14 
+ * limitations under the License.
15 
+ */
16 
+package com.remoteyourcam.usb.ptp.commands;
17 
+
18 
+import android.graphics.Bitmap;
19 
+
20 
+import com.remoteyourcam.usb.ptp.PtpAction;
21 
+import com.remoteyourcam.usb.ptp.PtpCamera;
22 
+import com.remoteyourcam.usb.ptp.PtpCamera.IO;
23 
+import com.remoteyourcam.usb.ptp.PtpConstants;
24 
+import com.remoteyourcam.usb.ptp.PtpConstants.Response;
25 
+import com.remoteyourcam.usb.ptp.model.ObjectInfo;
26 
+
27 
+public class RetrievePictureAction implements PtpAction {
28 
+
29 
+    private final PtpCamera camera;
30 
+    private final int objectHandle;
31 
+    private final int sampleSize;
32 
+
33 
+    public RetrievePictureAction(PtpCamera camera, int objectHandle, int sampleSize) {
34 
+        this.camera = camera;
35 
+        this.objectHandle = objectHandle;
36 
+        this.sampleSize = sampleSize;
37 
+    }
38 
+
39 
+    @Override
40 
+    public void exec(IO io) {
41 
+        GetObjectInfoCommand getInfo = new GetObjectInfoCommand(camera, objectHandle);
42 
+        io.handleCommand(getInfo);
43 
+
44 
+        if (getInfo.getResponseCode() != Response.Ok) {
45 
+            return;
46 
+        }
47 
+
48 
+        ObjectInfo objectInfo = getInfo.getObjectInfo();
49 
+        if (objectInfo == null) {
50 
+            return;
51 
+        }
52 
+
53 
+        Bitmap thumbnail = null;
54 
+        if (objectInfo.thumbFormat == PtpConstants.ObjectFormat.JFIF
55 
+                || objectInfo.thumbFormat == PtpConstants.ObjectFormat.EXIF_JPEG) {
56 
+            GetThumb getThumb = new GetThumb(camera, objectHandle);
57 
+            io.handleCommand(getThumb);
58 
+            if (getThumb.getResponseCode() == Response.Ok) {
59 
+                thumbnail = getThumb.getBitmap();
60 
+            }
61 
+        }
62 
+
63 
+        GetObjectCommand getObject = new GetObjectCommand(camera, objectHandle, sampleSize);
64 
+        io.handleCommand(getObject);
65 
+
66 
+        if (getObject.getResponseCode() != Response.Ok) {
67 
+            return;
68 
+        }
69 
+        if (getObject.getBitmap() == null) {
70 
+            if (getObject.isOutOfMemoryError()) {
71 
+                camera.onPictureReceived(objectHandle, getInfo.getObjectInfo().filename, thumbnail, null);
72 
+            }
73 
+            return;
74 
+        }
75 
+
76 
+        if (thumbnail == null) {
77 
+            // TODO resize real picture?
78 
+        }
79 
+
80 
+        camera.onPictureReceived(objectHandle, getInfo.getObjectInfo().filename, thumbnail, getObject.getBitmap());
81 
+    }
82 
+
83 
+    @Override
84 
+    public void reset() {
85 
+    }
86 
+}

+ 76 - 0
app/src/main/java/com/remoteyourcam/usb/ptp/commands/SetDevicePropValueCommand.java
Преглед на файла 

@@ -0,0 +1,76 @@
1 
+/**
2 
+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech
3 
+ *
4 
+ * Licensed under the Apache License, Version 2.0 (the "License");
5 
+ * you may not use this file except in compliance with the License.
6 
+ * You may obtain a copy of the License at
7 
+ *
8 
+ *     http://www.apache.org/licenses/LICENSE-2.0
9 
+ *
10 
+ * Unless required by applicable law or agreed to in writing, software
11 
+ * distributed under the License is distributed on an "AS IS" BASIS,
12 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 
+ * See the License for the specific language governing permissions and
14 
+ * limitations under the License.
15 
+ */
16 
+package com.remoteyourcam.usb.ptp.commands;
17 
+
18 
+import java.nio.ByteBuffer;
19 
+
20 
+import com.remoteyourcam.usb.ptp.PtpCamera;
21 
+import com.remoteyourcam.usb.ptp.PtpCamera.IO;
22 
+import com.remoteyourcam.usb.ptp.PtpConstants;
23 
+import com.remoteyourcam.usb.ptp.PtpConstants.Datatype;
24 
+import com.remoteyourcam.usb.ptp.PtpConstants.Operation;
25 
+import com.remoteyourcam.usb.ptp.PtpConstants.Response;
26 
+import com.remoteyourcam.usb.ptp.PtpConstants.Type;
27 
+
28 
+public class SetDevicePropValueCommand extends Command {
29 
+
30 
+    private final int property;
31 
+    private final int value;
32 
+    private final int datatype;
33 
+
34 
+    public SetDevicePropValueCommand(PtpCamera camera, int property, int value, int datatype) {
35 
+        super(camera);
36 
+        this.property = property;
37 
+        this.value = value;
38 
+        this.datatype = datatype;
39 
+        hasDataToSend = true;
40 
+    }
41 
+
42 
+    @Override
43 
+    public void exec(IO io) {
44 
+        io.handleCommand(this);
45 
+        if (responseCode == Response.DeviceBusy) {
46 
+            camera.onDeviceBusy(this, true);
47 
+            return;
48 
+        } else if (responseCode == Response.Ok) {
49 
+            camera.onPropertyChanged(property, value);
50 
+        }
51 
+    }
52 
+
53 
+    @Override
54 
+    public void encodeCommand(ByteBuffer b) {
55 
+        encodeCommand(b, Operation.SetDevicePropValue, property);
56 
+    }
57 
+
58 
+    @Override
59 
+    public void encodeData(ByteBuffer b) {
60 
+        // header
61 
+        b.putInt(12 + PtpConstants.getDatatypeSize(datatype));
62 
+        b.putShort((short) Type.Data);
63 
+        b.putShort((short) Operation.SetDevicePropValue);
64 
+        b.putInt(camera.currentTransactionId());
65 
+        // specific block
66 
+        if (datatype == Datatype.int8 || datatype == Datatype.uint8) {
67 
+            b.put((byte) value);
68 
+        } else if (datatype == Datatype.int16 || datatype == Datatype.uint16) {
69 
+            b.putShort((short) value);
70 
+        } else if (datatype == Datatype.int32 || datatype == Datatype.uint32) {
71 
+            b.putInt(value);
72 
+        } else {
73 
+            throw new UnsupportedOperationException();
74 
+        }
75 
+    }
76 
+}

+ 70 - 0
app/src/main/java/com/remoteyourcam/usb/ptp/commands/SimpleCommand.java
Преглед на файла 

@@ -0,0 +1,70 @@
1 
+/**
2 
+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech
3 
+ *
4 
+ * Licensed under the Apache License, Version 2.0 (the "License");
5 
+ * you may not use this file except in compliance with the License.
6 
+ * You may obtain a copy of the License at
7 
+ *
8 
+ *     http://www.apache.org/licenses/LICENSE-2.0
9 
+ *
10 
+ * Unless required by applicable law or agreed to in writing, software
11 
+ * distributed under the License is distributed on an "AS IS" BASIS,
12 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 
+ * See the License for the specific language governing permissions and
14 
+ * limitations under the License.
15 
+ */
16 
+package com.remoteyourcam.usb.ptp.commands;
17 
+
18 
+import java.nio.ByteBuffer;
19 
+
20 
+import com.remoteyourcam.usb.ptp.PtpCamera;
21 
+import com.remoteyourcam.usb.ptp.PtpCamera.IO;
22 
+import com.remoteyourcam.usb.ptp.PtpConstants.Response;
23 
+
24 
+public class SimpleCommand extends Command {
25 
+
26 
+    private final int operation;
27 
+    private int numParams;
28 
+    private int p0;
29 
+    private int p1;
30 
+
31 
+    public SimpleCommand(PtpCamera camera, int operation) {
32 
+        super(camera);
33 
+        this.operation = operation;
34 
+    }
35 
+
36 
+    public SimpleCommand(PtpCamera camera, int operation, int p0) {
37 
+        super(camera);
38 
+        this.operation = operation;
39 
+        this.p0 = p0;
40 
+        this.numParams = 1;
41 
+    }
42 
+
43 
+    public SimpleCommand(PtpCamera camera, int operation, int p0, int p1) {
44 
+        super(camera);
45 
+        this.operation = operation;
46 
+        this.p0 = p0;
47 
+        this.p1 = p1;
48 
+        this.numParams = 2;
49 
+    }
50 
+
51 
+    @Override
52 
+    public void exec(IO io) {
53 
+        io.handleCommand(this);
54 
+        if (responseCode == Response.DeviceBusy) {
55 
+            camera.onDeviceBusy(this, true);
56 
+            return;
57 
+        }
58 
+    }
59 
+
60 
+    @Override
61 
+    public void encodeCommand(ByteBuffer b) {
62 
+        if (numParams == 2) {
63 
+            encodeCommand(b, operation, p0, p1);
64 
+        } else if (numParams == 1) {
65 
+            encodeCommand(b, operation, p0);
66 
+        } else {
67 
+            encodeCommand(b, operation);
68 
+        }
69 
+    }
70 
+}

+ 29 - 0
app/src/main/java/com/remoteyourcam/usb/ptp/commands/eos/EosCommand.java
Преглед на файла 

@@ -0,0 +1,29 @@
1 
+/**
2 
+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech
3 
+ *
4 
+ * Licensed under the Apache License, Version 2.0 (the "License");
5 
+ * you may not use this file except in compliance with the License.
6 
+ * You may obtain a copy of the License at
7 
+ *
8 
+ *     http://www.apache.org/licenses/LICENSE-2.0
9 
+ *
10 
+ * Unless required by applicable law or agreed to in writing, software
11 
+ * distributed under the License is distributed on an "AS IS" BASIS,
12 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 
+ * See the License for the specific language governing permissions and
14 
+ * limitations under the License.
15 
+ */
16 
+package com.remoteyourcam.usb.ptp.commands.eos;
17 
+
18 
+import com.remoteyourcam.usb.ptp.EosCamera;
19 
+import com.remoteyourcam.usb.ptp.commands.Command;
20 
+
21 
+public abstract class EosCommand extends Command {
22 
+
23 
+    protected EosCamera camera;
24 
+
25 
+    public EosCommand(EosCamera camera) {
26 
+        super(camera);
27 
+        this.camera = camera;
28 
+    }
29 
+}

+ 184 - 0
app/src/main/java/com/remoteyourcam/usb/ptp/commands/eos/EosEventCheckCommand.java
Преглед на файла 

@@ -0,0 +1,184 @@
1 
+/**
2 
+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech
3 
+ *
4 
+ * Licensed under the Apache License, Version 2.0 (the "License");
5 
+ * you may not use this file except in compliance with the License.
6 
+ * You may obtain a copy of the License at
7 
+ *
8 
+ *     http://www.apache.org/licenses/LICENSE-2.0
9 
+ *
10 
+ * Unless required by applicable law or agreed to in writing, software
11 
+ * distributed under the License is distributed on an "AS IS" BASIS,
12 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 
+ * See the License for the specific language governing permissions and
14 
+ * limitations under the License.
15 
+ */
16 
+package com.remoteyourcam.usb.ptp.commands.eos;
17 
+
18 
+import java.nio.ByteBuffer;
19 
+
20 
+import android.util.Log;
21 
+
22 
+import com.remoteyourcam.usb.AppConfig;
23 
+import com.remoteyourcam.usb.ptp.EosCamera;
24 
+import com.remoteyourcam.usb.ptp.PacketUtil;
25 
+import com.remoteyourcam.usb.ptp.PtpCamera.IO;
26 
+import com.remoteyourcam.usb.ptp.PtpConstants;
27 
+import com.remoteyourcam.usb.ptp.PtpConstants.Event;
28 
+import com.remoteyourcam.usb.ptp.PtpConstants.Operation;
29 
+import com.remoteyourcam.usb.ptp.PtpConstants.Property;
30 
+import com.remoteyourcam.usb.ptp.PtpConstants.Response;
31 
+
32 
+public class EosEventCheckCommand extends EosCommand {
33 
+
34 
+    private static final String TAG = EosEventCheckCommand.class.getSimpleName();
35 
+
36 
+    public EosEventCheckCommand(EosCamera camera) {
37 
+        super(camera);
38 
+    }
39 
+
40 
+    @Override
41 
+    public void exec(IO io) {
42 
+        io.handleCommand(this);
43 
+        if (responseCode == Response.DeviceBusy) {
44 
+            camera.onDeviceBusy(this, false);
45 
+        }
46 
+    }
47 
+
48 
+    @Override
49 
+    public void encodeCommand(ByteBuffer b) {
50 
+        encodeCommand(b, Operation.EosEventCheck);
51 
+    }
52 
+
53 
+    @Override
54 
+    protected void decodeData(ByteBuffer b, int length) {
55 
+        while (b.position() < length) {
56 
+            int eventLength = b.getInt();
57 
+            int event = b.getInt();
58 
+            if (AppConfig.LOG) {
59 
+                Log.i(TAG, "event length " + eventLength);
60 
+                Log.i(TAG, "event type " + PtpConstants.eventToString(event));
61 
+            }
62 
+            switch (event) {
63 
+            case Event.EosObjectAdded: {
64 
+                int objectHandle = b.getInt();
65 
+                int storageId = b.getInt();
66 
+                int objectFormat = b.getShort();
67 
+                skip(b, eventLength - 18);
68 
+                camera.onEventDirItemCreated(objectHandle, storageId, objectFormat, "TODO");
69 
+                break;
70 
+            }
71 
+            case Event.EosDevicePropChanged: {
72 
+                int property = b.getInt();
73 
+                if (AppConfig.LOG) {
74 
+                    Log.i(TAG, "property " + PtpConstants.propertyToString(property));
75 
+                }
76 
+                switch (property) {
77 
+                case Property.EosApertureValue:
78 
+                case Property.EosShutterSpeed:
79 
+                case Property.EosIsoSpeed:
80 
+                case Property.EosWhitebalance:
81 
+                case Property.EosEvfOutputDevice:
82 
+                case Property.EosShootingMode:
83 
+                case Property.EosAvailableShots:
84 
+                case Property.EosColorTemperature:
85 
+                case Property.EosAfMode:
86 
+                case Property.EosMeteringMode:
87 
+                case Property.EosExposureCompensation:
88 
+                case Property.EosPictureStyle:
89 
+                case Property.EosEvfMode: {
90 
+                    int value = b.getInt();
91 
+                    if (AppConfig.LOG) {
92 
+                        Log.i(TAG, "value " + value);
93 
+                    }
94 
+                    camera.onPropertyChanged(property, value);
95 
+                    break;
96 
+                }
97 
+                default:
98 
+                    if (AppConfig.LOG && eventLength <= 200) {
99 
+                        PacketUtil.logHexdump(TAG, b.array(), b.position(), eventLength - 12);
100 
+                    }
101 
+                    skip(b, eventLength - 12);
102 
+                    break;
103 
+                }
104 
+                break;
105 
+            }
106 
+            case Event.EosDevicePropDescChanged: {
107 
+                int property = b.getInt();
108 
+                if (AppConfig.LOG) {
109 
+                    Log.i(TAG, "property " + PtpConstants.propertyToString(property));
110 
+                }
111 
+                switch (property) {
112 
+                case Property.EosApertureValue:
113 
+                case Property.EosShutterSpeed:
114 
+                case Property.EosIsoSpeed:
115 
+                case Property.EosMeteringMode:
116 
+                case Property.EosPictureStyle:
117 
+                case Property.EosExposureCompensation:
118 
+                case Property.EosColorTemperature:
119 
+                case Property.EosWhitebalance: {
120 
+                    /* int dataType = */b.getInt();
121 
+                    int num = b.getInt();
122 
+                    if (AppConfig.LOG) {
123 
+                        Log.i(TAG, "property desc with num " + num);
124 
+                    }
125 
+                    if (eventLength != 20 + 4 * num) {
126 
+                        if (AppConfig.LOG) {
127 
+                            Log.i(TAG, String.format("Event Desc length invalid should be %d but is %d", 20 + 4 * num,
128 
+                                    eventLength));
129 
+                            PacketUtil.logHexdump(TAG, b.array(), b.position() - 20, eventLength);
130 
+                        }
131 
+                    }
132 
+                    int[] values = new int[num];
133 
+                    for (int i = 0; i < num; ++i) {
134 
+                        values[i] = b.getInt();
135 
+                    }
136 
+                    if (eventLength != 20 + 4 * num) {
137 
+                        for (int i = 20 + 4 * num; i < eventLength; ++i) {
138 
+                            b.get();
139 
+                        }
140 
+                    }
141 
+                    camera.onPropertyDescChanged(property, values);
142 
+                    break;
143 
+                }
144 
+                default:
145 
+                    if (AppConfig.LOG && eventLength <= 50) {
146 
+                        PacketUtil.logHexdump(TAG, b.array(), b.position(), eventLength - 12);
147 
+                    }
148 
+                    skip(b, eventLength - 12);
149 
+                }
150 
+                break;
151 
+            }
152 
+            case Event.EosBulbExposureTime: {
153 
+                int seconds = b.getInt();
154 
+                camera.onBulbExposureTime(seconds);
155 
+                break;
156 
+            }
157 
+            case Event.EosCameraStatus: {
158 
+                // 0 - capture stopped
159 
+                // 1 - capture started
160 
+                int status = b.getInt();
161 
+                camera.onEventCameraCapture(status != 0);
162 
+                break;
163 
+            }
164 
+            case Event.EosWillSoonShutdown: {
165 
+                /* int seconds = */b.getInt();
166 
+                //TODO
167 
+                break;
168 
+            }
169 
+            default:
170 
+                //                if (BuildConfig.LOG) {
171 
+                //                    PacketUtil.logHexdump(b.array(), b.position(), eventLength - 8);
172 
+                //                }
173 
+                skip(b, eventLength - 8);
174 
+                break;
175 
+            }
176 
+        }
177 
+    }
178 
+
179 
+    private void skip(ByteBuffer b, int length) {
180 
+        for (int i = 0; i < length; ++i) {
181 
+            b.get();
182 
+        }
183 
+    }
184 
+}

+ 153 - 0
app/src/main/java/com/remoteyourcam/usb/ptp/commands/eos/EosGetLiveViewPictureCommand.java
Преглед на файла 

@@ -0,0 +1,153 @@
1 
+/**
2 
+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech
3 
+ *
4 
+ * Licensed under the Apache License, Version 2.0 (the "License");
5 
+ * you may not use this file except in compliance with the License.
6 
+ * You may obtain a copy of the License at
7 
+ *
8 
+ *     http://www.apache.org/licenses/LICENSE-2.0
9 
+ *
10 
+ * Unless required by applicable law or agreed to in writing, software
11 
+ * distributed under the License is distributed on an "AS IS" BASIS,
12 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 
+ * See the License for the specific language governing permissions and
14 
+ * limitations under the License.
15 
+ */
16 
+package com.remoteyourcam.usb.ptp.commands.eos;
17 
+
18 
+import java.nio.ByteBuffer;
19 
+import java.nio.ByteOrder;
20 
+
21 
+import android.graphics.BitmapFactory;
22 
+import android.graphics.BitmapFactory.Options;
23 
+import android.util.Log;
24 
+
25 
+import com.remoteyourcam.usb.AppConfig;
26 
+import com.remoteyourcam.usb.ptp.EosCamera;
27 
+import com.remoteyourcam.usb.ptp.PtpCamera.IO;
28 
+import com.remoteyourcam.usb.ptp.PtpConstants.Operation;
29 
+import com.remoteyourcam.usb.ptp.PtpConstants.Response;
30 
+import com.remoteyourcam.usb.ptp.model.LiveViewData;
31 
+
32 
+public class EosGetLiveViewPictureCommand extends EosCommand {
33 
+
34 
+    private static final String TAG = EosGetLiveViewPictureCommand.class.getSimpleName();
35 
+    private static byte[] tmpStorage = new byte[0x4000];
36 
+    private final Options options;
37 
+    private LiveViewData data;
38 
+
39 
+    public EosGetLiveViewPictureCommand(EosCamera camera, LiveViewData data) {
40 
+        super(camera);
41 
+        if (data == null) {
42 
+            this.data = new LiveViewData();
43 
+            this.data.histogram = ByteBuffer.allocate(1024 * 4);
44 
+            this.data.histogram.order(ByteOrder.LITTLE_ENDIAN);
45 
+        } else {
46 
+            this.data = data;
47 
+        }
48 
+        options = new BitmapFactory.Options();
49 
+        options.inBitmap = this.data.bitmap;
50 
+        options.inSampleSize = 1;
51 
+        options.inTempStorage = tmpStorage;
52 
+        this.data.bitmap = null;
53 
+    }
54 
+
55 
+    @Override
56 
+    public void exec(IO io) {
57 
+        io.handleCommand(this);
58 
+        if (responseCode == Response.DeviceBusy) {
59 
+            camera.onDeviceBusy(this, true);
60 
+            return;
61 
+        }
62 
+        if (this.data.bitmap != null && responseCode == Response.Ok) {
63 
+            camera.onLiveViewReceived(data);
64 
+        } else {
65 
+            camera.onLiveViewReceived(null);
66 
+        }
67 
+    }
68 
+
69 
+    @Override
70 
+    public void encodeCommand(ByteBuffer b) {
71 
+        encodeCommand(b, Operation.EosGetLiveViewPicture, 0x100000);
72 
+    }
73 
+
74 
+    @Override
75 
+    protected void decodeData(ByteBuffer b, int length) {
76 
+
77 
+        data.hasHistogram = false;
78 
+        data.hasAfFrame = false;
79 
+
80 
+        if (length < 1000) {
81 
+            if (AppConfig.LOG) {
82 
+                Log.w(TAG, String.format("liveview data size too small %d", length));
83 
+            }
84 
+            return;
85 
+        }
86 
+
87 
+        try {
88 
+
89 
+            while (b.hasRemaining()) {
90 
+                int subLength = b.getInt();
91 
+                int type = b.getInt();
92 
+
93 
+                if (subLength < 8) {
94 
+                    throw new RuntimeException("Invalid sub size " + subLength);
95 
+                }
96 
+
97 
+                int unknownInt = 0;
98 
+
99 
+                switch (type) {
100 
+                case 0x01:
101 
+                    data.bitmap = BitmapFactory.decodeByteArray(b.array(), b.position(), subLength - 8, options);
102 
+                    b.position(b.position() + subLength - 8);
103 
+                    break;
104 
+                case 0x04:
105 
+                    data.zoomFactor = b.getInt();
106 
+                    break;
107 
+                case 0x05:
108 
+                    // zoomfocusx, zoomfocusy
109 
+                    data.zoomRectRight = b.getInt();
110 
+                    data.zoomRectBottom = b.getInt();
111 
+                    if (AppConfig.LOG) {
112 
+                        Log.i(TAG, "header 5 " + data.zoomRectRight + " " + data.zoomRectBottom);
113 
+                    }
114 
+                    break;
115 
+                case 0x06:
116 
+                    // imagex, imagey (if zoomed should be non zero)
117 
+                    data.zoomRectLeft = b.getInt();
118 
+                    data.zoomRectTop = b.getInt();
119 
+                    if (AppConfig.LOG) {
120 
+                        Log.i(TAG, "header 6 " + data.zoomRectLeft + " " + data.zoomRectTop);
121 
+                    }
122 
+                    break;
123 
+                case 0x07:
124 
+                    unknownInt = b.getInt();
125 
+                    if (AppConfig.LOG) {
126 
+                        Log.i(TAG, "header 7 " + unknownInt + " " + subLength);
127 
+                    }
128 
+                    break;
129 
+                case 0x03:
130 
+                    data.hasHistogram = true;
131 
+                    b.get(data.histogram.array(), 0, 1024 * 4);
132 
+                    break;
133 
+                case 0x08: // faces if faces focus
134 
+                case 0x0e: // TODO original width, original height
135 
+                default:
136 
+                    b.position(b.position() + subLength - 8);
137 
+                    if (AppConfig.LOG) {
138 
+                        Log.i(TAG, "unknown header " + type + " size " + subLength);
139 
+                    }
140 
+                    break;
141 
+                }
142 
+
143 
+                if (length - b.position() < 8) {
144 
+                    break;
145 
+                }
146 
+            }
147 
+
148 
+        } catch (RuntimeException e) {
149 
+            Log.e(TAG, "" + e.toString());
150 
+            Log.e(TAG, "" + e.getLocalizedMessage());
151 
+        }
152 
+    }
153 
+}

+ 65 - 0
app/src/main/java/com/remoteyourcam/usb/ptp/commands/eos/EosOpenSessionAction.java
Преглед на файла 

@@ -0,0 +1,65 @@
1 
+/**
2 
+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech
3 
+ *
4 
+ * Licensed under the Apache License, Version 2.0 (the "License");
5 
+ * you may not use this file except in compliance with the License.
6 
+ * You may obtain a copy of the License at
7 
+ *
8 
+ *     http://www.apache.org/licenses/LICENSE-2.0
9 
+ *
10 
+ * Unless required by applicable law or agreed to in writing, software
11 
+ * distributed under the License is distributed on an "AS IS" BASIS,
12 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 
+ * See the License for the specific language governing permissions and
14 
+ * limitations under the License.
15 
+ */
16 
+package com.remoteyourcam.usb.ptp.commands.eos;
17 
+
18 
+import com.remoteyourcam.usb.ptp.EosCamera;
19 
+import com.remoteyourcam.usb.ptp.PtpAction;
20 
+import com.remoteyourcam.usb.ptp.PtpConstants;
21 
+import com.remoteyourcam.usb.ptp.PtpCamera.IO;
22 
+import com.remoteyourcam.usb.ptp.commands.OpenSessionCommand;
23 
+
24 
+public class EosOpenSessionAction implements PtpAction {
25 
+
26 
+    private final EosCamera camera;
27 
+
28 
+    public EosOpenSessionAction(EosCamera camera) {
29 
+        this.camera = camera;
30 
+    }
31 
+
32 
+    @Override
33 
+    public void exec(IO io) {
34 
+        OpenSessionCommand openSession = new OpenSessionCommand(camera);
35 
+        io.handleCommand(openSession);
36 
+        if (openSession.getResponseCode() == PtpConstants.Response.Ok) {
37 
+            EosSetPcModeCommand setPcMode = new EosSetPcModeCommand(camera);
38 
+            io.handleCommand(setPcMode);
39 
+            if (setPcMode.getResponseCode() == PtpConstants.Response.Ok) {
40 
+                EosSetExtendedEventInfoCommand c = new EosSetExtendedEventInfoCommand(camera);
41 
+                io.handleCommand(c);
42 
+                if (c.getResponseCode() == PtpConstants.Response.Ok) {
43 
+                    camera.onSessionOpened();
44 
+                    return;
45 
+                } else {
46 
+                    camera.onPtpError(String.format(
47 
+                            "Couldn't open session! Setting extended event info failed with error code \"%s\"",
48 
+                            PtpConstants.responseToString(c.getResponseCode())));
49 
+                }
50 
+            } else {
51 
+                camera.onPtpError(String.format(
52 
+                        "Couldn't open session! Setting PcMode property failed with error code \"%s\"",
53 
+                        PtpConstants.responseToString(setPcMode.getResponseCode())));
54 
+            }
55 
+        } else {
56 
+            camera.onPtpError(String.format(
57 
+                    "Couldn't open session! Open session command failed with error code \"%s\"",
58 
+                    PtpConstants.responseToString(openSession.getResponseCode())));
59 
+        }
60 
+    }
61 
+
62 
+    @Override
63 
+    public void reset() {
64 
+    }
65 
+}

+ 46 - 0
app/src/main/java/com/remoteyourcam/usb/ptp/commands/eos/EosSetExtendedEventInfoCommand.java
Преглед на файла 

@@ -0,0 +1,46 @@
1 
+/**
2 
+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech
3 
+ *
4 
+ * Licensed under the Apache License, Version 2.0 (the "License");
5 
+ * you may not use this file except in compliance with the License.
6 
+ * You may obtain a copy of the License at
7 
+ *
8 
+ *     http://www.apache.org/licenses/LICENSE-2.0
9 
+ *
10 
+ * Unless required by applicable law or agreed to in writing, software
11 
+ * distributed under the License is distributed on an "AS IS" BASIS,
12 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 
+ * See the License for the specific language governing permissions and
14 
+ * limitations under the License.
15 
+ */
16 
+package com.remoteyourcam.usb.ptp.commands.eos;
17 
+
18 
+import java.nio.ByteBuffer;
19 
+
20 
+import com.remoteyourcam.usb.ptp.EosCamera;
21 
+import com.remoteyourcam.usb.ptp.PtpConstants;
22 
+import com.remoteyourcam.usb.ptp.PtpCamera.IO;
23 
+import com.remoteyourcam.usb.ptp.PtpConstants.Operation;
24 
+import com.remoteyourcam.usb.ptp.PtpConstants.Response;
25 
+
26 
+public class EosSetExtendedEventInfoCommand extends EosCommand {
27 
+
28 
+    public EosSetExtendedEventInfoCommand(EosCamera camera) {
29 
+        super(camera);
30 
+    }
31 
+
32 
+    @Override
33 
+    public void exec(IO io) {
34 
+        io.handleCommand(this);
35 
+        if (responseCode != Response.Ok) {
36 
+            camera.onPtpError(String.format(
37 
+                    "Couldn't initialize session! Setting extended event info failed, error code %s",
38 
+                    PtpConstants.responseToString(responseCode)));
39 
+        }
40 
+    }
41 
+
42 
+    @Override
43 
+    public void encodeCommand(ByteBuffer b) {
44 
+        encodeCommand(b, Operation.EosSetEventMode, 1);
45 
+    }
46 
+}

+ 84 - 0
app/src/main/java/com/remoteyourcam/usb/ptp/commands/eos/EosSetLiveViewAction.java
Преглед на файла 

@@ -0,0 +1,84 @@
1 
+/**
2 
+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech
3 
+ *
4 
+ * Licensed under the Apache License, Version 2.0 (the "License");
5 
+ * you may not use this file except in compliance with the License.
6 
+ * You may obtain a copy of the License at
7 
+ *
8 
+ *     http://www.apache.org/licenses/LICENSE-2.0
9 
+ *
10 
+ * Unless required by applicable law or agreed to in writing, software
11 
+ * distributed under the License is distributed on an "AS IS" BASIS,
12 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 
+ * See the License for the specific language governing permissions and
14 
+ * limitations under the License.
15 
+ */
16 
+package com.remoteyourcam.usb.ptp.commands.eos;
17 
+
18 
+import com.remoteyourcam.usb.ptp.EosCamera;
19 
+import com.remoteyourcam.usb.ptp.EosConstants;
20 
+import com.remoteyourcam.usb.ptp.PtpAction;
21 
+import com.remoteyourcam.usb.ptp.EosConstants.EvfMode;
22 
+import com.remoteyourcam.usb.ptp.PtpCamera.IO;
23 
+import com.remoteyourcam.usb.ptp.PtpConstants.Property;
24 
+import com.remoteyourcam.usb.ptp.PtpConstants.Response;
25 
+
26 
+public class EosSetLiveViewAction implements PtpAction {
27 
+
28 
+    private final EosCamera camera;
29 
+    private final boolean enabled;
30 
+
31 
+    public EosSetLiveViewAction(EosCamera camera, boolean enabled) {
32 
+        this.camera = camera;
33 
+        this.enabled = enabled;
34 
+    }
35 
+
36 
+    @Override
37 
+    public void exec(IO io) {
38 
+        int evfMode = camera.getPtpProperty(Property.EosEvfMode);
39 
+
40 
+        if (enabled && evfMode != EvfMode.ENABLE || !enabled && evfMode != EvfMode.DISABLE) {
41 
+            EosSetPropertyCommand setEvfMode = new EosSetPropertyCommand(camera, Property.EosEvfMode,
42 
+                    enabled ? EvfMode.ENABLE : EvfMode.DISABLE);
43 
+            io.handleCommand(setEvfMode);
44 
+
45 
+            if (setEvfMode.getResponseCode() == Response.DeviceBusy) {
46 
+                camera.onDeviceBusy(this, true);
47 
+                return;
48 
+            } else if (setEvfMode.getResponseCode() != Response.Ok) {
49 
+                camera.onPtpWarning("Couldn't open live view");
50 
+                return;
51 
+            }
52 
+        }
53 
+
54 
+        int outputDevice = camera.getPtpProperty(Property.EosEvfOutputDevice);
55 
+
56 
+        if (enabled) {
57 
+            outputDevice |= EosConstants.EvfOutputDevice.PC;
58 
+        } else {
59 
+            outputDevice &= ~EosConstants.EvfOutputDevice.PC;
60 
+        }
61 
+
62 
+        EosSetPropertyCommand setOutputDevice = new EosSetPropertyCommand(camera, Property.EosEvfOutputDevice,
63 
+                outputDevice);
64 
+        io.handleCommand(setOutputDevice);
65 
+
66 
+        if (setOutputDevice.getResponseCode() == Response.DeviceBusy) {
67 
+            camera.onDeviceBusy(this, true);
68 
+        } else if (setOutputDevice.getResponseCode() == Response.Ok) {
69 
+            if (!enabled) {
70 
+                camera.onLiveViewStopped();
71 
+            } else {
72 
+                camera.onLiveViewStarted();
73 
+            }
74 
+            return;
75 
+        } else {
76 
+            camera.onPtpWarning("Couldn't open live view");
77 
+        }
78 
+
79 
+    }
80 
+
81 
+    @Override
82 
+    public void reset() {
83 
+    }
84 
+}

+ 45 - 0
app/src/main/java/com/remoteyourcam/usb/ptp/commands/eos/EosSetPcModeCommand.java
Преглед на файла 

@@ -0,0 +1,45 @@
1 
+/**
2 
+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech
3 
+ *
4 
+ * Licensed under the Apache License, Version 2.0 (the "License");
5 
+ * you may not use this file except in compliance with the License.
6 
+ * You may obtain a copy of the License at
7 
+ *
8 
+ *     http://www.apache.org/licenses/LICENSE-2.0
9 
+ *
10 
+ * Unless required by applicable law or agreed to in writing, software
11 
+ * distributed under the License is distributed on an "AS IS" BASIS,
12 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 
+ * See the License for the specific language governing permissions and
14 
+ * limitations under the License.
15 
+ */
16 
+package com.remoteyourcam.usb.ptp.commands.eos;
17 
+
18 
+import java.nio.ByteBuffer;
19 
+
20 
+import com.remoteyourcam.usb.ptp.EosCamera;
21 
+import com.remoteyourcam.usb.ptp.PtpConstants;
22 
+import com.remoteyourcam.usb.ptp.PtpCamera.IO;
23 
+import com.remoteyourcam.usb.ptp.PtpConstants.Operation;
24 
+import com.remoteyourcam.usb.ptp.PtpConstants.Response;
25 
+
26 
+public class EosSetPcModeCommand extends EosCommand {
27 
+
28 
+    public EosSetPcModeCommand(EosCamera camera) {
29 
+        super(camera);
30 
+    }
31 
+
32 
+    @Override
33 
+    public void exec(IO io) {
34 
+        io.handleCommand(this);
35 
+        if (responseCode != Response.Ok) {
36 
+            camera.onPtpError(String.format("Couldn't initialize session! setting PC Mode failed, error code %s",
37 
+                    PtpConstants.responseToString(responseCode)));
38 
+        }
39 
+    }
40 
+
41 
+    @Override
42 
+    public void encodeCommand(ByteBuffer b) {
43 
+        encodeCommand(b, Operation.EosSetPCConnectMode, 1);
44 
+    }
45 
+}

+ 64 - 0
app/src/main/java/com/remoteyourcam/usb/ptp/commands/eos/EosSetPropertyCommand.java
Преглед на файла 

@@ -0,0 +1,64 @@
1 
+/**
2 
+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech
3 
+ *
4 
+ * Licensed under the Apache License, Version 2.0 (the "License");
5 
+ * you may not use this file except in compliance with the License.
6 
+ * You may obtain a copy of the License at
7 
+ *
8 
+ *     http://www.apache.org/licenses/LICENSE-2.0
9 
+ *
10 
+ * Unless required by applicable law or agreed to in writing, software
11 
+ * distributed under the License is distributed on an "AS IS" BASIS,
12 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 
+ * See the License for the specific language governing permissions and
14 
+ * limitations under the License.
15 
+ */
16 
+package com.remoteyourcam.usb.ptp.commands.eos;
17 
+
18 
+import java.nio.ByteBuffer;
19 
+
20 
+import com.remoteyourcam.usb.ptp.EosCamera;
21 
+import com.remoteyourcam.usb.ptp.PtpCamera.IO;
22 
+import com.remoteyourcam.usb.ptp.PtpConstants.Operation;
23 
+import com.remoteyourcam.usb.ptp.PtpConstants.Response;
24 
+import com.remoteyourcam.usb.ptp.PtpConstants.Type;
25 
+
26 
+public class EosSetPropertyCommand extends EosCommand {
27 
+
28 
+    private final int property;
29 
+    private final int value;
30 
+
31 
+    public EosSetPropertyCommand(EosCamera camera, int property, int value) {
32 
+        super(camera);
33 
+        hasDataToSend = true;
34 
+        this.property = property;
35 
+        this.value = value;
36 
+    }
37 
+
38 
+    @Override
39 
+    public void exec(IO io) {
40 
+        io.handleCommand(this);
41 
+        if (responseCode == Response.DeviceBusy) {
42 
+            camera.onDeviceBusy(this, true);
43 
+            return;
44 
+        }
45 
+    }
46 
+
47 
+    @Override
48 
+    public void encodeCommand(ByteBuffer b) {
49 
+        encodeCommand(b, Operation.EosSetDevicePropValue);
50 
+    }
51 
+
52 
+    @Override
53 
+    public void encodeData(ByteBuffer b) {
54 
+        // header
55 
+        b.putInt(24);
56 
+        b.putShort((short) Type.Data);
57 
+        b.putShort((short) Operation.EosSetDevicePropValue);
58 
+        b.putInt(camera.currentTransactionId());
59 
+        // specific block
60 
+        b.putInt(0x0C);
61 
+        b.putInt(property);
62 
+        b.putInt(value);
63 
+    }
64 
+}

+ 43 - 0
app/src/main/java/com/remoteyourcam/usb/ptp/commands/eos/EosTakePictureCommand.java
Преглед на файла 

@@ -0,0 +1,43 @@
1 
+/**
2 
+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech
3 
+ *
4 
+ * Licensed under the Apache License, Version 2.0 (the "License");
5 
+ * you may not use this file except in compliance with the License.
6 
+ * You may obtain a copy of the License at
7 
+ *
8 
+ *     http://www.apache.org/licenses/LICENSE-2.0
9 
+ *
10 
+ * Unless required by applicable law or agreed to in writing, software
11 
+ * distributed under the License is distributed on an "AS IS" BASIS,
12 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 
+ * See the License for the specific language governing permissions and
14 
+ * limitations under the License.
15 
+ */
16 
+package com.remoteyourcam.usb.ptp.commands.eos;
17 
+
18 
+import java.nio.ByteBuffer;
19 
+
20 
+import com.remoteyourcam.usb.ptp.EosCamera;
21 
+import com.remoteyourcam.usb.ptp.PtpCamera.IO;
22 
+import com.remoteyourcam.usb.ptp.PtpConstants.Operation;
23 
+import com.remoteyourcam.usb.ptp.PtpConstants.Response;
24 
+
25 
+public class EosTakePictureCommand extends EosCommand {
26 
+
27 
+    public EosTakePictureCommand(EosCamera camera) {
28 
+        super(camera);
29 
+    }
30 
+
31 
+    @Override
32 
+    public void exec(IO io) {
33 
+        io.handleCommand(this);
34 
+        if (responseCode == Response.DeviceBusy) {
35 
+            camera.onDeviceBusy(this, true);
36 
+        }
37 
+    }
38 
+
39 
+    @Override
40 
+    public void encodeCommand(ByteBuffer b) {
41 
+        encodeCommand(b, Operation.EosTakePicture);
42 
+    }
43 
+}

+ 47 - 0
app/src/main/java/com/remoteyourcam/usb/ptp/commands/nikon/NikonAfDriveCommand.java
Преглед на файла 

@@ -0,0 +1,47 @@
1 
+/**
2 
+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech
3 
+ *
4 
+ * Licensed under the Apache License, Version 2.0 (the "License");
5 
+ * you may not use this file except in compliance with the License.
6 
+ * You may obtain a copy of the License at
7 
+ *
8 
+ *     http://www.apache.org/licenses/LICENSE-2.0
9 
+ *
10 
+ * Unless required by applicable law or agreed to in writing, software
11 
+ * distributed under the License is distributed on an "AS IS" BASIS,
12 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 
+ * See the License for the specific language governing permissions and
14 
+ * limitations under the License.
15 
+ */
16 
+package com.remoteyourcam.usb.ptp.commands.nikon;
17 
+
18 
+import java.nio.ByteBuffer;
19 
+
20 
+import com.remoteyourcam.usb.ptp.NikonCamera;
21 
+import com.remoteyourcam.usb.ptp.PtpCamera.IO;
22 
+import com.remoteyourcam.usb.ptp.PtpConstants.Operation;
23 
+import com.remoteyourcam.usb.ptp.PtpConstants.Response;
24 
+
25 
+public class NikonAfDriveCommand extends NikonCommand {
26 
+
27 
+    public NikonAfDriveCommand(NikonCamera camera) {
28 
+        super(camera);
29 
+    }
30 
+
31 
+    @Override
32 
+    public void exec(IO io) {
33 
+        //        if (camera.isInActivationTypePhase()) {
34 
+        //            return;
35 
+        //        }
36 
+        io.handleCommand(this);
37 
+        if (getResponseCode() == Response.Ok) {
38 
+            camera.onFocusStarted();
39 
+            camera.enqueue(new NikonAfDriveDeviceReadyCommand(camera), 200);
40 
+        }
41 
+    }
42 
+
43 
+    @Override
44 
+    public void encodeCommand(ByteBuffer b) {
45 
+        encodeCommand(b, Operation.NikonAfDrive);
46 
+    }
47 
+}

+ 46 - 0
app/src/main/java/com/remoteyourcam/usb/ptp/commands/nikon/NikonAfDriveDeviceReadyCommand.java
Преглед на файла 

@@ -0,0 +1,46 @@
1 
+/**
2 
+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech
3 
+ *
4 
+ * Licensed under the Apache License, Version 2.0 (the "License");
5 
+ * you may not use this file except in compliance with the License.
6 
+ * You may obtain a copy of the License at
7 
+ *
8 
+ *     http://www.apache.org/licenses/LICENSE-2.0
9 
+ *
10 
+ * Unless required by applicable law or agreed to in writing, software
11 
+ * distributed under the License is distributed on an "AS IS" BASIS,
12 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 
+ * See the License for the specific language governing permissions and
14 
+ * limitations under the License.
15 
+ */
16 
+package com.remoteyourcam.usb.ptp.commands.nikon;
17 
+
18 
+import java.nio.ByteBuffer;
19 
+
20 
+import com.remoteyourcam.usb.ptp.NikonCamera;
21 
+import com.remoteyourcam.usb.ptp.PtpCamera.IO;
22 
+import com.remoteyourcam.usb.ptp.PtpConstants.Operation;
23 
+import com.remoteyourcam.usb.ptp.PtpConstants.Response;
24 
+
25 
+public class NikonAfDriveDeviceReadyCommand extends NikonCommand {
26 
+
27 
+    public NikonAfDriveDeviceReadyCommand(NikonCamera camera) {
28 
+        super(camera);
29 
+    }
30 
+
31 
+    @Override
32 
+    public void exec(IO io) {
33 
+        io.handleCommand(this);
34 
+        if (getResponseCode() == Response.DeviceBusy) {
35 
+            reset();
36 
+            camera.enqueue(this, 200);
37 
+        } else {
38 
+            camera.onFocusEnded(getResponseCode() == Response.Ok);
39 
+        }
40 
+    }
41 
+
42 
+    @Override
43 
+    public void encodeCommand(ByteBuffer b) {
44 
+        encodeCommand(b, Operation.NikonDeviceReady);
45 
+    }
46 
+}

+ 54 - 0
app/src/main/java/com/remoteyourcam/usb/ptp/commands/nikon/NikonCloseSessionAction.java
Преглед на файла 

@@ -0,0 +1,54 @@
1 
+/**
2 
+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech
3 
+ *
4 
+ * Licensed under the Apache License, Version 2.0 (the "License");
5 
+ * you may not use this file except in compliance with the License.
6 
+ * You may obtain a copy of the License at
7 
+ *
8 
+ *     http://www.apache.org/licenses/LICENSE-2.0
9 
+ *
10 
+ * Unless required by applicable law or agreed to in writing, software
11 
+ * distributed under the License is distributed on an "AS IS" BASIS,
12 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 
+ * See the License for the specific language governing permissions and
14 
+ * limitations under the License.
15 
+ */
16 
+package com.remoteyourcam.usb.ptp.commands.nikon;
17 
+
18 
+import com.remoteyourcam.usb.ptp.NikonCamera;
19 
+import com.remoteyourcam.usb.ptp.PtpAction;
20 
+import com.remoteyourcam.usb.ptp.PtpCamera.IO;
21 
+import com.remoteyourcam.usb.ptp.PtpConstants.Datatype;
22 
+import com.remoteyourcam.usb.ptp.PtpConstants.Property;
23 
+import com.remoteyourcam.usb.ptp.PtpConstants.Response;
24 
+import com.remoteyourcam.usb.ptp.commands.CloseSessionCommand;
25 
+import com.remoteyourcam.usb.ptp.commands.SetDevicePropValueCommand;
26 
+
27 
+public class NikonCloseSessionAction implements PtpAction {
28 
+
29 
+    private final NikonCamera camera;
30 
+
31 
+    public NikonCloseSessionAction(NikonCamera camera) {
32 
+        this.camera = camera;
33 
+    }
34 
+
35 
+    @Override
36 
+    public void exec(IO io) {
37 
+        SetDevicePropValueCommand setRecordingMedia = new SetDevicePropValueCommand(camera,
38 
+                Property.NikonRecordingMedia, 0,
39 
+                Datatype.uint8);
40 
+        io.handleCommand(setRecordingMedia);
41 
+
42 
+        if (setRecordingMedia.getResponseCode() == Response.DeviceBusy) {
43 
+            camera.onDeviceBusy(this, true);
44 
+            return;
45 
+        }
46 
+
47 
+        io.handleCommand(new CloseSessionCommand(camera));
48 
+        camera.onSessionClosed();
49 
+    }
50 
+
51 
+    @Override
52 
+    public void reset() {
53 
+    }
54 
+}

+ 29 - 0
app/src/main/java/com/remoteyourcam/usb/ptp/commands/nikon/NikonCommand.java
Преглед на файла 

@@ -0,0 +1,29 @@
1 
+/**
2 
+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech
3 
+ *
4 
+ * Licensed under the Apache License, Version 2.0 (the "License");
5 
+ * you may not use this file except in compliance with the License.
6 
+ * You may obtain a copy of the License at
7 
+ *
8 
+ *     http://www.apache.org/licenses/LICENSE-2.0
9 
+ *
10 
+ * Unless required by applicable law or agreed to in writing, software
11 
+ * distributed under the License is distributed on an "AS IS" BASIS,
12 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 
+ * See the License for the specific language governing permissions and
14 
+ * limitations under the License.
15 
+ */
16 
+package com.remoteyourcam.usb.ptp.commands.nikon;
17 
+
18 
+import com.remoteyourcam.usb.ptp.NikonCamera;
19 
+import com.remoteyourcam.usb.ptp.commands.Command;
20 
+
21 
+public abstract class NikonCommand extends Command {
22 
+
23 
+    protected NikonCamera camera;
24 
+
25 
+    public NikonCommand(NikonCamera camera) {
26 
+        super(camera);
27 
+        this.camera = camera;
28 
+    }
29 
+}

+ 76 - 0
app/src/main/java/com/remoteyourcam/usb/ptp/commands/nikon/NikonEventCheckCommand.java
Преглед на файла 

@@ -0,0 +1,76 @@
1 
+/**
2 
+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech
3 
+ *
4 
+ * Licensed under the Apache License, Version 2.0 (the "License");
5 
+ * you may not use this file except in compliance with the License.
6 
+ * You may obtain a copy of the License at
7 
+ *
8 
+ *     http://www.apache.org/licenses/LICENSE-2.0
9 
+ *
10 
+ * Unless required by applicable law or agreed to in writing, software
11 
+ * distributed under the License is distributed on an "AS IS" BASIS,
12 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 
+ * See the License for the specific language governing permissions and
14 
+ * limitations under the License.
15 
+ */
16 
+package com.remoteyourcam.usb.ptp.commands.nikon;
17 
+
18 
+import java.nio.ByteBuffer;
19 
+
20 
+import android.util.Log;
21 
+
22 
+import com.remoteyourcam.usb.AppConfig;
23 
+import com.remoteyourcam.usb.ptp.NikonCamera;
24 
+import com.remoteyourcam.usb.ptp.PtpCamera.IO;
25 
+import com.remoteyourcam.usb.ptp.PtpConstants;
26 
+import com.remoteyourcam.usb.ptp.PtpConstants.Event;
27 
+import com.remoteyourcam.usb.ptp.PtpConstants.Operation;
28 
+
29 
+public class NikonEventCheckCommand extends NikonCommand {
30 
+
31 
+    private static final String TAG = NikonEventCheckCommand.class.getSimpleName();
32 
+
33 
+    public NikonEventCheckCommand(NikonCamera camera) {
34 
+        super(camera);
35 
+    }
36 
+
37 
+    @Override
38 
+    public void exec(IO io) {
39 
+        io.handleCommand(this);
40 
+    }
41 
+
42 
+    @Override
43 
+    public void encodeCommand(ByteBuffer b) {
44 
+        encodeCommand(b, Operation.NikonGetEvent);
45 
+    }
46 
+
47 
+    @Override
48 
+    protected void decodeData(ByteBuffer b, int length) {
49 
+        int count = b.getShort();
50 
+
51 
+        while (count > 0) {
52 
+            --count;
53 
+
54 
+            int eventCode = b.getShort();
55 
+            int eventParam = b.getInt();
56 
+
57 
+            if (AppConfig.LOG) {
58 
+                Log.i(TAG,
59 
+                        String.format("event %s value %s(%04x)", PtpConstants.eventToString(eventCode),
60 
+                                PtpConstants.propertyToString(eventParam), eventParam));
61 
+            }
62 
+
63 
+            switch (eventCode) {
64 
+            case Event.ObjectAdded:
65 
+                camera.onEventObjectAdded(eventParam);
66 
+                break;
67 
+            case Event.DevicePropChanged:
68 
+                camera.onEventDevicePropChanged(eventParam);
69 
+                break;
70 
+            case Event.CaptureComplete:
71 
+                camera.onEventCaptureComplete();
72 
+                break;
73 
+            }
74 
+        }
75 
+    }
76 
+}

+ 70 - 0
app/src/main/java/com/remoteyourcam/usb/ptp/commands/nikon/NikonGetLiveViewImageAction.java
Преглед на файла 

@@ -0,0 +1,70 @@
1 
+/**
2 
+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech
3 
+ *
4 
+ * Licensed under the Apache License, Version 2.0 (the "License");
5 
+ * you may not use this file except in compliance with the License.
6 
+ * You may obtain a copy of the License at
7 
+ *
8 
+ *     http://www.apache.org/licenses/LICENSE-2.0
9 
+ *
10 
+ * Unless required by applicable law or agreed to in writing, software
11 
+ * distributed under the License is distributed on an "AS IS" BASIS,
12 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 
+ * See the License for the specific language governing permissions and
14 
+ * limitations under the License.
15 
+ */
16 
+package com.remoteyourcam.usb.ptp.commands.nikon;
17 
+
18 
+import com.remoteyourcam.usb.ptp.NikonCamera;
19 
+import com.remoteyourcam.usb.ptp.PtpAction;
20 
+import com.remoteyourcam.usb.ptp.PtpCamera.IO;
21 
+import com.remoteyourcam.usb.ptp.PtpConstants.Operation;
22 
+import com.remoteyourcam.usb.ptp.PtpConstants.Response;
23 
+import com.remoteyourcam.usb.ptp.commands.SimpleCommand;
24 
+import com.remoteyourcam.usb.ptp.model.LiveViewData;
25 
+
26 
+public class NikonGetLiveViewImageAction implements PtpAction {
27 
+
28 
+    private final NikonCamera camera;
29 
+    private final LiveViewData reuse;
30 
+
31 
+    public NikonGetLiveViewImageAction(NikonCamera camera, LiveViewData reuse) {
32 
+        this.camera = camera;
33 
+        this.reuse = reuse;
34 
+    }
35 
+
36 
+    @Override
37 
+    public void exec(IO io) {
38 
+        SimpleCommand simpleCmd = new SimpleCommand(camera, Operation.NikonStartLiveView);
39 
+        io.handleCommand(simpleCmd);
40 
+
41 
+        if (simpleCmd.getResponseCode() != Response.Ok) {
42 
+            return;
43 
+        }
44 
+
45 
+        SimpleCommand deviceReady = new SimpleCommand(camera, Operation.NikonDeviceReady);
46 
+        for (int i = 0; i < 10; ++i) {
47 
+            try {
48 
+                Thread.sleep(300);
49 
+            } catch (InterruptedException e) {
50 
+                // nop
51 
+            }
52 
+
53 
+            deviceReady.reset();
54 
+            io.handleCommand(deviceReady);
55 
+            if (deviceReady.getResponseCode() == Response.DeviceBusy) {
56 
+                // still waiting
57 
+            } else if (deviceReady.getResponseCode() == Response.Ok) {
58 
+                camera.onLiveViewRestarted();
59 
+                io.handleCommand(new NikonGetLiveViewImageCommand(camera, reuse));
60 
+                return;
61 
+            } else {
62 
+                return;
63 
+            }
64 
+        }
65 
+    }
66 
+
67 
+    @Override
68 
+    public void reset() {
69 
+    }
70 
+}

+ 169 - 0
app/src/main/java/com/remoteyourcam/usb/ptp/commands/nikon/NikonGetLiveViewImageCommand.java
Преглед на файла 

@@ -0,0 +1,169 @@
1 
+/**
2 
+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech
3 
+ *
4 
+ * Licensed under the Apache License, Version 2.0 (the "License");
5 
+ * you may not use this file except in compliance with the License.
6 
+ * You may obtain a copy of the License at
7 
+ *
8 
+ *     http://www.apache.org/licenses/LICENSE-2.0
9 
+ *
10 
+ * Unless required by applicable law or agreed to in writing, software
11 
+ * distributed under the License is distributed on an "AS IS" BASIS,
12 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 
+ * See the License for the specific language governing permissions and
14 
+ * limitations under the License.
15 
+ */
16 
+package com.remoteyourcam.usb.ptp.commands.nikon;
17 
+
18 
+import java.nio.ByteBuffer;
19 
+import java.nio.ByteOrder;
20 
+
21 
+import org.acra.ErrorReporter;
22 
+
23 
+import android.graphics.BitmapFactory;
24 
+import android.graphics.BitmapFactory.Options;
25 
+import android.util.Log;
26 
+
27 
+import com.remoteyourcam.usb.AppConfig;
28 
+import com.remoteyourcam.usb.ptp.NikonCamera;
29 
+import com.remoteyourcam.usb.ptp.PacketUtil;
30 
+import com.remoteyourcam.usb.ptp.PtpCamera.IO;
31 
+import com.remoteyourcam.usb.ptp.PtpConstants.Operation;
32 
+import com.remoteyourcam.usb.ptp.PtpConstants.Product;
33 
+import com.remoteyourcam.usb.ptp.PtpConstants.Response;
34 
+import com.remoteyourcam.usb.ptp.model.LiveViewData;
35 
+
36 
+public class NikonGetLiveViewImageCommand extends NikonCommand {
37 
+
38 
+    private static boolean haveAddedDumpToAcra = false;
39 
+
40 
+    private static final String TAG = NikonGetLiveViewImageCommand.class.getSimpleName();
41 
+    private static byte[] tmpStorage = new byte[0x4000];
42 
+    private final Options options;
43 
+    private LiveViewData data;
44 
+
45 
+    public NikonGetLiveViewImageCommand(NikonCamera camera, LiveViewData data) {
46 
+        super(camera);
47 
+        this.data = data;
48 
+        if (data == null) {
49 
+            this.data = new LiveViewData();
50 
+            //this.data.histogram = ByteBuffer.allocate(1024 * 4);
51 
+            //this.data.histogram.order(ByteOrder.LITTLE_ENDIAN);
52 
+        } else {
53 
+            this.data = data;
54 
+        }
55 
+        options = new BitmapFactory.Options();
56 
+        options.inBitmap = this.data.bitmap;
57 
+        options.inSampleSize = 1;
58 
+        options.inTempStorage = tmpStorage;
59 
+        this.data.bitmap = null;
60 
+    }
61 
+
62 
+    @Override
63 
+    public void exec(IO io) {
64 
+        if (!camera.isLiveViewOpen()) {
65 
+            return;
66 
+        }
67 
+        io.handleCommand(this);
68 
+        if (responseCode == Response.DeviceBusy) {
69 
+            camera.onDeviceBusy(this, true);
70 
+            return;
71 
+        }
72 
+        data.hasHistogram = false;
73 
+        if (this.data.bitmap != null && responseCode == Response.Ok) {
74 
+            camera.onLiveViewReceived(data);
75 
+        } else {
76 
+            camera.onLiveViewReceived(null);
77 
+        }
78 
+    }
79 
+
80 
+    @Override
81 
+    public void encodeCommand(ByteBuffer b) {
82 
+        encodeCommand(b, Operation.NikonGetLiveViewImage);
83 
+    }
84 
+
85 
+    @Override
86 
+    protected void decodeData(ByteBuffer b, int length) {
87 
+        if (length <= 128) {
88 
+            return;
89 
+        }
90 
+
91 
+        data.hasAfFrame = false;
92 
+
93 
+        int productId = camera.getProductId();
94 
+        int start = b.position();
95 
+        int pictureOffset;
96 
+
97 
+        switch (productId) {
98 
+        case Product.NikonD5000:
99 
+        case Product.NikonD3S:
100 
+        case Product.NikonD90:
101 
+            pictureOffset = 128;
102 
+            break;
103 
+        case Product.NikonD3X:
104 
+        case Product.NikonD300S:
105 
+        case Product.NikonD3:
106 
+        case Product.NikonD300:
107 
+        case Product.NikonD700:
108 
+            pictureOffset = 64;
109 
+            break;
110 
+        case Product.NikonD7000:
111 
+        case Product.NikonD5100:
112 
+            pictureOffset = 384;
113 
+            break;
114 
+        default:
115 
+            if (AppConfig.USE_ACRA && !haveAddedDumpToAcra) {
116 
+                try {
117 
+                    haveAddedDumpToAcra = true;
118 
+                    String hex = PacketUtil.hexDumpToString(b.array(), start, length < 728 ? length : 728);
119 
+                    ErrorReporter.getInstance().putCustomData("liveview hexdump", hex);
120 
+                } catch (Throwable e) {
121 
+                    // no fail
122 
+                }
123 
+            }
124 
+            return;
125 
+        }
126 
+
127 
+        b.order(ByteOrder.BIG_ENDIAN);
128 
+
129 
+        // read af frame
130 
+        {
131 
+            data.hasAfFrame = true;
132 
+
133 
+            int jpegImageWidth = b.getShort() & 0xFFFF;
134 
+            int jpegImageHeight = b.getShort() & 0xFFFF;
135 
+            int wholeWidth = b.getShort() & 0xFFFF;
136 
+            int wholeHeight = b.getShort() & 0xFFFF;
137 
+
138 
+            float multX = jpegImageWidth / (float) wholeWidth;
139 
+            float multY = jpegImageHeight / (float) wholeHeight;
140 
+
141 
+            b.position(start + 16);
142 
+            data.nikonWholeWidth = wholeWidth;
143 
+            data.nikonWholeHeight = wholeHeight;
144 
+            data.nikonAfFrameWidth = (int) ((b.getShort() & 0xFFFF) * multX);
145 
+            data.nikonAfFrameHeight = (int) ((b.getShort() & 0xFFFF) * multY);
146 
+            data.nikonAfFrameCenterX = (int) ((b.getShort() & 0xFFFF) * multX);
147 
+            data.nikonAfFrameCenterY = (int) ((b.getShort() & 0xFFFF) * multY);
148 
+        }
149 
+
150 
+        b.order(ByteOrder.LITTLE_ENDIAN);
151 
+
152 
+        b.position(start + pictureOffset);
153 
+
154 
+        if (b.remaining() <= 128) {
155 
+            data.bitmap = null;
156 
+            return;
157 
+        }
158 
+
159 
+        try {
160 
+            data.bitmap = BitmapFactory.decodeByteArray(b.array(), b.position(), length - b.position(), options);
161 
+        } catch (RuntimeException e) {
162 
+            Log.e(TAG, "decoding failed " + e.toString());
163 
+            Log.e(TAG, e.getLocalizedMessage());
164 
+            if (AppConfig.LOG) {
165 
+                PacketUtil.logHexdump(TAG, b.array(), start, 512);
166 
+            }
167 
+        }
168 
+    }
169 
+}

+ 51 - 0
app/src/main/java/com/remoteyourcam/usb/ptp/commands/nikon/NikonGetVendorPropCodesCommand.java
Преглед на файла 

@@ -0,0 +1,51 @@
1 
+/**
2 
+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech
3 
+ *
4 
+ * Licensed under the Apache License, Version 2.0 (the "License");
5 
+ * you may not use this file except in compliance with the License.
6 
+ * You may obtain a copy of the License at
7 
+ *
8 
+ *     http://www.apache.org/licenses/LICENSE-2.0
9 
+ *
10 
+ * Unless required by applicable law or agreed to in writing, software
11 
+ * distributed under the License is distributed on an "AS IS" BASIS,
12 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 
+ * See the License for the specific language governing permissions and
14 
+ * limitations under the License.
15 
+ */
16 
+package com.remoteyourcam.usb.ptp.commands.nikon;
17 
+
18 
+import java.nio.ByteBuffer;
19 
+
20 
+import com.remoteyourcam.usb.ptp.NikonCamera;
21 
+import com.remoteyourcam.usb.ptp.PacketUtil;
22 
+import com.remoteyourcam.usb.ptp.PtpCamera.IO;
23 
+import com.remoteyourcam.usb.ptp.PtpConstants.Operation;
24 
+
25 
+public class NikonGetVendorPropCodesCommand extends NikonCommand {
26 
+
27 
+    private int[] propertyCodes = new int[0];
28 
+
29 
+    public NikonGetVendorPropCodesCommand(NikonCamera camera) {
30 
+        super(camera);
31 
+    }
32 
+
33 
+    public int[] getPropertyCodes() {
34 
+        return propertyCodes;
35 
+    }
36 
+
37 
+    @Override
38 
+    public void exec(IO io) {
39 
+        throw new UnsupportedOperationException();
40 
+    }
41 
+
42 
+    @Override
43 
+    public void encodeCommand(ByteBuffer b) {
44 
+        encodeCommand(b, Operation.NikonGetVendorPropCodes);
45 
+    }
46 
+
47 
+    @Override
48 
+    protected void decodeData(ByteBuffer b, int length) {
49 
+        propertyCodes = PacketUtil.readU16Array(b);
50 
+    }
51 
+}

+ 69 - 0
app/src/main/java/com/remoteyourcam/usb/ptp/commands/nikon/NikonOpenSessionAction.java
Преглед на файла 

@@ -0,0 +1,69 @@
1 
+/**
2 
+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech
3 
+ *
4 
+ * Licensed under the Apache License, Version 2.0 (the "License");
5 
+ * you may not use this file except in compliance with the License.
6 
+ * You may obtain a copy of the License at
7 
+ *
8 
+ *     http://www.apache.org/licenses/LICENSE-2.0
9 
+ *
10 
+ * Unless required by applicable law or agreed to in writing, software
11 
+ * distributed under the License is distributed on an "AS IS" BASIS,
12 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 
+ * See the License for the specific language governing permissions and
14 
+ * limitations under the License.
15 
+ */
16 
+package com.remoteyourcam.usb.ptp.commands.nikon;
17 
+
18 
+import com.remoteyourcam.usb.ptp.NikonCamera;
19 
+import com.remoteyourcam.usb.ptp.PtpAction;
20 
+import com.remoteyourcam.usb.ptp.PtpCamera.IO;
21 
+import com.remoteyourcam.usb.ptp.PtpConstants;
22 
+import com.remoteyourcam.usb.ptp.PtpConstants.Datatype;
23 
+import com.remoteyourcam.usb.ptp.PtpConstants.Operation;
24 
+import com.remoteyourcam.usb.ptp.PtpConstants.Property;
25 
+import com.remoteyourcam.usb.ptp.commands.OpenSessionCommand;
26 
+import com.remoteyourcam.usb.ptp.commands.SetDevicePropValueCommand;
27 
+
28 
+public class NikonOpenSessionAction implements PtpAction {
29 
+
30 
+    private final NikonCamera camera;
31 
+
32 
+    public NikonOpenSessionAction(NikonCamera camera) {
33 
+        this.camera = camera;
34 
+    }
35 
+
36 
+    @Override
37 
+    public void exec(IO io) {
38 
+        OpenSessionCommand openSession = new OpenSessionCommand(camera);
39 
+        io.handleCommand(openSession);
40 
+        if (openSession.getResponseCode() == PtpConstants.Response.Ok) {
41 
+            if (camera.hasSupportForOperation(Operation.NikonGetVendorPropCodes)) {
42 
+                NikonGetVendorPropCodesCommand getPropCodes = new NikonGetVendorPropCodesCommand(camera);
43 
+                io.handleCommand(getPropCodes);
44 
+                SetDevicePropValueCommand c = new SetDevicePropValueCommand(camera, Property.NikonRecordingMedia, 1,
45 
+                        Datatype.uint8);
46 
+                io.handleCommand(c);
47 
+                if (getPropCodes.getResponseCode() == PtpConstants.Response.Ok
48 
+                        && c.getResponseCode() == PtpConstants.Response.Ok) {
49 
+                    camera.setVendorPropCodes(getPropCodes.getPropertyCodes());
50 
+                    camera.onSessionOpened();
51 
+                } else {
52 
+                    camera.onPtpError(String.format(
53 
+                            "Couldn't read device property codes! Open session command failed with error code \"%s\"",
54 
+                            PtpConstants.responseToString(getPropCodes.getResponseCode())));
55 
+                }
56 
+            } else {
57 
+                camera.onSessionOpened();
58 
+            }
59 
+        } else {
60 
+            camera.onPtpError(String.format(
61 
+                    "Couldn't open session! Open session command failed with error code \"%s\"",
62 
+                    PtpConstants.responseToString(openSession.getResponseCode())));
63 
+        }
64 
+    }
65 
+
66 
+    @Override
67 
+    public void reset() {
68 
+    }
69 
+}

+ 66 - 0
app/src/main/java/com/remoteyourcam/usb/ptp/commands/nikon/NikonStartLiveViewAction.java
Преглед на файла 

@@ -0,0 +1,66 @@
1 
+/**
2 
+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech
3 
+ *
4 
+ * Licensed under the Apache License, Version 2.0 (the "License");
5 
+ * you may not use this file except in compliance with the License.
6 
+ * You may obtain a copy of the License at
7 
+ *
8 
+ *     http://www.apache.org/licenses/LICENSE-2.0
9 
+ *
10 
+ * Unless required by applicable law or agreed to in writing, software
11 
+ * distributed under the License is distributed on an "AS IS" BASIS,
12 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 
+ * See the License for the specific language governing permissions and
14 
+ * limitations under the License.
15 
+ */
16 
+package com.remoteyourcam.usb.ptp.commands.nikon;
17 
+
18 
+import com.remoteyourcam.usb.ptp.NikonCamera;
19 
+import com.remoteyourcam.usb.ptp.PtpAction;
20 
+import com.remoteyourcam.usb.ptp.PtpCamera.IO;
21 
+import com.remoteyourcam.usb.ptp.PtpConstants.Operation;
22 
+import com.remoteyourcam.usb.ptp.PtpConstants.Response;
23 
+import com.remoteyourcam.usb.ptp.commands.SimpleCommand;
24 
+
25 
+public class NikonStartLiveViewAction implements PtpAction {
26 
+
27 
+    private final NikonCamera camera;
28 
+
29 
+    public NikonStartLiveViewAction(NikonCamera camera) {
30 
+        this.camera = camera;
31 
+    }
32 
+
33 
+    @Override
34 
+    public void exec(IO io) {
35 
+        SimpleCommand simpleCmd = new SimpleCommand(camera, Operation.NikonStartLiveView);
36 
+        io.handleCommand(simpleCmd);
37 
+
38 
+        if (simpleCmd.getResponseCode() != Response.Ok) {
39 
+            return;
40 
+        }
41 
+
42 
+        SimpleCommand deviceReady = new SimpleCommand(camera, Operation.NikonDeviceReady);
43 
+        for (int i = 0; i < 10; ++i) {
44 
+            try {
45 
+                Thread.sleep(300);
46 
+            } catch (InterruptedException e) {
47 
+                // nop
48 
+            }
49 
+
50 
+            deviceReady.reset();
51 
+            io.handleCommand(deviceReady);
52 
+            if (deviceReady.getResponseCode() == Response.DeviceBusy) {
53 
+                // still waiting
54 
+            } else if (deviceReady.getResponseCode() == Response.Ok) {
55 
+                camera.onLiveViewStarted();
56 
+                return;
57 
+            } else {
58 
+                return;
59 
+            }
60 
+        }
61 
+    }
62 
+
63 
+    @Override
64 
+    public void reset() {
65 
+    }
66 
+}

+ 54 - 0
app/src/main/java/com/remoteyourcam/usb/ptp/commands/nikon/NikonStopLiveViewAction.java
Преглед на файла 

@@ -0,0 +1,54 @@
1 
+/**
2 
+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech
3 
+ *
4 
+ * Licensed under the Apache License, Version 2.0 (the "License");
5 
+ * you may not use this file except in compliance with the License.
6 
+ * You may obtain a copy of the License at
7 
+ *
8 
+ *     http://www.apache.org/licenses/LICENSE-2.0
9 
+ *
10 
+ * Unless required by applicable law or agreed to in writing, software
11 
+ * distributed under the License is distributed on an "AS IS" BASIS,
12 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 
+ * See the License for the specific language governing permissions and
14 
+ * limitations under the License.
15 
+ */
16 
+package com.remoteyourcam.usb.ptp.commands.nikon;
17 
+
18 
+import com.remoteyourcam.usb.ptp.NikonCamera;
19 
+import com.remoteyourcam.usb.ptp.PtpAction;
20 
+import com.remoteyourcam.usb.ptp.PtpCamera.IO;
21 
+import com.remoteyourcam.usb.ptp.PtpConstants.Operation;
22 
+import com.remoteyourcam.usb.ptp.PtpConstants.Response;
23 
+import com.remoteyourcam.usb.ptp.commands.SimpleCommand;
24 
+
25 
+public class NikonStopLiveViewAction implements PtpAction {
26 
+
27 
+    private final NikonCamera camera;
28 
+    private final boolean notifyUser;
29 
+
30 
+    public NikonStopLiveViewAction(NikonCamera camera, boolean notifyUser) {
31 
+        this.camera = camera;
32 
+        this.notifyUser = notifyUser;
33 
+    }
34 
+
35 
+    @Override
36 
+    public void exec(IO io) {
37 
+        SimpleCommand simpleCmd = new SimpleCommand(camera, Operation.NikonEndLiveView);
38 
+        io.handleCommand(simpleCmd);
39 
+
40 
+        if (simpleCmd.getResponseCode() == Response.DeviceBusy) {
41 
+            camera.onDeviceBusy(this, true);
42 
+        } else {
43 
+            if (notifyUser) {
44 
+                camera.onLiveViewStopped();
45 
+            } else {
46 
+                camera.onLiveViewStoppedInternal();
47 
+            }
48 
+        }
49 
+    }
50 
+
51 
+    @Override
52 
+    public void reset() {
53 
+    }
54 
+}

+ 113 - 0
app/src/main/java/com/remoteyourcam/usb/ptp/model/DeviceInfo.java
Преглед на файла 

@@ -0,0 +1,113 @@
1 
+/**
2 
+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech
3 
+ *
4 
+ * Licensed under the Apache License, Version 2.0 (the "License");
5 
+ * you may not use this file except in compliance with the License.
6 
+ * You may obtain a copy of the License at
7 
+ *
8 
+ *     http://www.apache.org/licenses/LICENSE-2.0
9 
+ *
10 
+ * Unless required by applicable law or agreed to in writing, software
11 
+ * distributed under the License is distributed on an "AS IS" BASIS,
12 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 
+ * See the License for the specific language governing permissions and
14 
+ * limitations under the License.
15 
+ */
16 
+package com.remoteyourcam.usb.ptp.model;
17 
+
18 
+import java.nio.ByteBuffer;
19 
+import java.util.Arrays;
20 
+
21 
+import com.remoteyourcam.usb.ptp.PacketUtil;
22 
+import com.remoteyourcam.usb.ptp.PtpConstants;
23 
+
24 
+/**
25 
+ * Device info data set as defined by PTP standard.
26 
+ */
27 
+public class DeviceInfo {
28 
+
29 
+    public short standardVersion;
30 
+    public int vendorExtensionId;
31 
+    public short vendorExtensionVersion;
32 
+    public String vendorExtensionDesc;
33 
+    public short functionalMode;
34 
+    public int[] operationsSupported;
35 
+    public int[] eventsSupported;
36 
+    public int[] devicePropertiesSupported;
37 
+    public int[] captureFormats;
38 
+    public int[] imageFormats;
39 
+    public String manufacture;
40 
+    public String model;
41 
+    public String deviceVersion;
42 
+    public String serialNumber;
43 
+
44 
+    public DeviceInfo(ByteBuffer b, int length) {
45 
+        decode(b, length);
46 
+    }
47 
+
48 
+    public DeviceInfo() {
49 
+    }
50 
+
51 
+    public void decode(ByteBuffer b, int length) {
52 
+        standardVersion = b.getShort();
53 
+        vendorExtensionId = b.getInt();
54 
+        vendorExtensionVersion = b.getShort();
55 
+        vendorExtensionDesc = PacketUtil.readString(b);
56 
+        functionalMode = b.getShort();
57 
+        operationsSupported = PacketUtil.readU16Array(b);
58 
+        eventsSupported = PacketUtil.readU16Array(b);
59 
+        devicePropertiesSupported = PacketUtil.readU16Array(b);
60 
+        captureFormats = PacketUtil.readU16Array(b);
61 
+        imageFormats = PacketUtil.readU16Array(b);
62 
+        manufacture = PacketUtil.readString(b);
63 
+        model = PacketUtil.readString(b);
64 
+        deviceVersion = PacketUtil.readString(b);
65 
+        serialNumber = PacketUtil.readString(b);
66 
+    }
67 
+
68 
+    public void encode(ByteBuffer b) {
69 
+        b.putShort(standardVersion);
70 
+        b.putInt(vendorExtensionId);
71 
+        b.putInt(vendorExtensionVersion);
72 
+        PacketUtil.writeString(b, "");
73 
+        b.putShort(functionalMode);
74 
+        PacketUtil.writeU16Array(b, new int[0]);
75 
+        PacketUtil.writeU16Array(b, new int[0]);
76 
+        PacketUtil.writeU16Array(b, new int[0]);
77 
+        PacketUtil.writeU16Array(b, new int[0]);
78 
+        PacketUtil.writeU16Array(b, new int[0]);
79 
+        PacketUtil.writeString(b, "");
80 
+        PacketUtil.writeString(b, "");
81 
+        PacketUtil.writeString(b, "");
82 
+    }
83 
+
84 
+    @Override
85 
+    public String toString() {
86 
+        // Changes here have to reflect changes in PtpConstants.main()
87 
+        StringBuilder b = new StringBuilder();
88 
+        b.append("DeviceInfo\n");
89 
+        b.append("StandardVersion: ").append(standardVersion).append('\n');
90 
+        b.append("VendorExtensionId: ").append(vendorExtensionId).append('\n');
91 
+        b.append("VendorExtensionVersion: ").append(vendorExtensionVersion).append('\n');
92 
+        b.append("VendorExtensionDesc: ").append(vendorExtensionDesc).append('\n');
93 
+        b.append("FunctionalMode: ").append(functionalMode).append('\n');
94 
+        appendU16Array(b, "OperationsSupported", PtpConstants.Operation.class, operationsSupported);
95 
+        appendU16Array(b, "EventsSupported", PtpConstants.Event.class, eventsSupported);
96 
+        appendU16Array(b, "DevicePropertiesSupported", PtpConstants.Property.class, devicePropertiesSupported);
97 
+        appendU16Array(b, "CaptureFormats", PtpConstants.ObjectFormat.class, captureFormats);
98 
+        appendU16Array(b, "ImageFormats", PtpConstants.ObjectFormat.class, imageFormats);
99 
+        b.append("Manufacture: ").append(manufacture).append('\n');
100 
+        b.append("Model: ").append(model).append('\n');
101 
+        b.append("DeviceVersion: ").append(deviceVersion).append('\n');
102 
+        b.append("SerialNumber: ").append(serialNumber).append('\n');
103 
+        return b.toString();
104 
+    }
105 
+
106 
+    private static void appendU16Array(StringBuilder b, String name, Class<?> cl, int[] a) {
107 
+        Arrays.sort(a);
108 
+        b.append(name).append(":\n");
109 
+        for (int i = 0; i < a.length; ++i) {
110 
+            b.append("    ").append(PtpConstants.constantToString(cl, a[i])).append('\n');
111 
+        }
112 
+    }
113 
+}

+ 102 - 0
app/src/main/java/com/remoteyourcam/usb/ptp/model/DevicePropDesc.java
Преглед на файла 

@@ -0,0 +1,102 @@
1 
+/**
2 
+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech
3 
+ *
4 
+ * Licensed under the Apache License, Version 2.0 (the "License");
5 
+ * you may not use this file except in compliance with the License.
6 
+ * You may obtain a copy of the License at
7 
+ *
8 
+ *     http://www.apache.org/licenses/LICENSE-2.0
9 
+ *
10 
+ * Unless required by applicable law or agreed to in writing, software
11 
+ * distributed under the License is distributed on an "AS IS" BASIS,
12 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 
+ * See the License for the specific language governing permissions and
14 
+ * limitations under the License.
15 
+ */
16 
+package com.remoteyourcam.usb.ptp.model;
17 
+
18 
+import java.nio.ByteBuffer;
19 
+
20 
+import com.remoteyourcam.usb.ptp.PacketUtil;
21 
+import com.remoteyourcam.usb.ptp.PtpConstants.Datatype;
22 
+
23 
+public class DevicePropDesc {
24 
+
25 
+    public int code;
26 
+    public int datatype;
27 
+    public boolean readOnly;
28 
+    public int factoryDefault;
29 
+    public int currentValue;
30 
+    public int[] description;
31 
+
32 
+    public DevicePropDesc() {
33 
+    }
34 
+
35 
+    public DevicePropDesc(ByteBuffer b, int length) {
36 
+        decode(b, length);
37 
+    }
38 
+
39 
+    public void decode(ByteBuffer b, int length) {
40 
+        code = b.getShort() & 0xFFFF;
41 
+        datatype = b.getShort() & 0xFFFF;
42 
+        readOnly = b.get() == 0;
43 
+
44 
+        if (datatype == Datatype.int8 || datatype == Datatype.uint8) {
45 
+            factoryDefault = b.get() & 0xFF;
46 
+            currentValue = b.get() & 0xFF;
47 
+            int form = b.get();
48 
+            if (form == 2) {
49 
+                description = PacketUtil.readU8Enumeration(b);
50 
+            } else if (form == 1) {
51 
+                int mini = b.get();
52 
+                int maxi = b.get();
53 
+                int step = b.get();
54 
+                description = new int[(maxi - mini) / step + 1];
55 
+                for (int i = 0; i < description.length; ++i) {
56 
+                    description[i] = mini + step * i;
57 
+                }
58 
+            }
59 
+        } else if (datatype == Datatype.uint16) {
60 
+            factoryDefault = b.getShort() & 0xFFFF;
61 
+            currentValue = b.getShort() & 0xFFFF;
62 
+            int form = b.get();
63 
+            if (form == 2) {
64 
+                description = PacketUtil.readU16Enumeration(b);
65 
+            } else if (form == 1) {
66 
+                int mini = b.getShort() & 0xFFFF;
67 
+                int maxi = b.getShort() & 0xFFFF;
68 
+                int step = b.getShort() & 0xFFFF;
69 
+                description = new int[(maxi - mini) / step + 1];
70 
+                for (int i = 0; i < description.length; ++i) {
71 
+                    description[i] = mini + step * i;
72 
+                }
73 
+            }
74 
+        } else if (datatype == Datatype.int16) {
75 
+            factoryDefault = b.getShort();
76 
+            currentValue = b.getShort();
77 
+            int form = b.get();
78 
+            if (form == 2) {
79 
+                description = PacketUtil.readS16Enumeration(b);
80 
+            } else if (form == 1) {
81 
+                int mini = b.getShort();
82 
+                int maxi = b.getShort();
83 
+                int step = b.getShort();
84 
+                description = new int[(maxi - mini) / step + 1];
85 
+                for (int i = 0; i < description.length; ++i) {
86 
+                    description[i] = mini + step * i;
87 
+                }
88 
+            }
89 
+        } else if (datatype == Datatype.int32 || datatype == Datatype.uint32) {
90 
+            factoryDefault = b.getInt();
91 
+            currentValue = b.getInt();
92 
+            int form = b.get();
93 
+            if (form == 2) {
94 
+                description = PacketUtil.readU32Enumeration(b);
95 
+            }
96 
+        }
97 
+
98 
+        if (description == null) {
99 
+            description = new int[0];
100 
+        }
101 
+    }
102 
+}

+ 44 - 0
app/src/main/java/com/remoteyourcam/usb/ptp/model/LiveViewData.java
Преглед на файла 

@@ -0,0 +1,44 @@
1 
+/**
2 
+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech
3 
+ *
4 
+ * Licensed under the Apache License, Version 2.0 (the "License");
5 
+ * you may not use this file except in compliance with the License.
6 
+ * You may obtain a copy of the License at
7 
+ *
8 
+ *     http://www.apache.org/licenses/LICENSE-2.0
9 
+ *
10 
+ * Unless required by applicable law or agreed to in writing, software
11 
+ * distributed under the License is distributed on an "AS IS" BASIS,
12 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 
+ * See the License for the specific language governing permissions and
14 
+ * limitations under the License.
15 
+ */
16 
+package com.remoteyourcam.usb.ptp.model;
17 
+
18 
+import java.nio.ByteBuffer;
19 
+
20 
+import android.graphics.Bitmap;
21 
+
22 
+public class LiveViewData {
23 
+
24 
+    public Bitmap bitmap;
25 
+
26 
+    public int zoomFactor;
27 
+    public int zoomRectLeft;
28 
+    public int zoomRectTop;
29 
+    public int zoomRectRight;
30 
+    public int zoomRectBottom;
31 
+
32 
+    public boolean hasHistogram;
33 
+    public ByteBuffer histogram;
34 
+
35 
+    // dimensions are in bitmap size
36 
+    public boolean hasAfFrame;
37 
+    public int nikonAfFrameCenterX;
38 
+    public int nikonAfFrameCenterY;
39 
+    public int nikonAfFrameWidth;
40 
+    public int nikonAfFrameHeight;
41 
+
42 
+    public int nikonWholeWidth;
43 
+    public int nikonWholeHeight;
44 
+}

+ 101 - 0
app/src/main/java/com/remoteyourcam/usb/ptp/model/ObjectInfo.java
Преглед на файла 

@@ -0,0 +1,101 @@
1 
+/**
2 
+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech
3 
+ *
4 
+ * Licensed under the Apache License, Version 2.0 (the "License");
5 
+ * you may not use this file except in compliance with the License.
6 
+ * You may obtain a copy of the License at
7 
+ *
8 
+ *     http://www.apache.org/licenses/LICENSE-2.0
9 
+ *
10 
+ * Unless required by applicable law or agreed to in writing, software
11 
+ * distributed under the License is distributed on an "AS IS" BASIS,
12 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 
+ * See the License for the specific language governing permissions and
14 
+ * limitations under the License.
15 
+ */
16 
+package com.remoteyourcam.usb.ptp.model;
17 
+
18 
+import java.nio.ByteBuffer;
19 
+
20 
+import com.remoteyourcam.usb.ptp.PacketUtil;
21 
+import com.remoteyourcam.usb.ptp.PtpConstants;
22 
+
23 
+/**
24 
+ * Object info data set as defined by the PTP standard.
25 
+ */
26 
+public class ObjectInfo {
27 
+
28 
+    public int storageId;
29 
+    public int objectFormat;
30 
+    public int protectionStatus;
31 
+    public int objectCompressedSize;
32 
+    public int thumbFormat;
33 
+    public int thumbCompressedSize;
34 
+    public int thumbPixWidth;
35 
+    public int thumbPixHeight;
36 
+    public int imagePixWidth;
37 
+    public int imagePixHeight;
38 
+    public int imageBitDepth;
39 
+    public int parentObject;
40 
+    public int associationType;
41 
+    public int associationDesc;
42 
+    public int sequenceNumber;
43 
+    public String filename;
44 
+    public String captureDate;
45 
+    public String modificationDate;
46 
+    public int keywords;
47 
+
48 
+    public ObjectInfo() {
49 
+    }
50 
+
51 
+    public ObjectInfo(ByteBuffer b, int length) {
52 
+        decode(b, length);
53 
+    }
54 
+
55 
+    public void decode(ByteBuffer b, int length) {
56 
+        storageId = b.getInt();
57 
+        objectFormat = b.getShort();
58 
+        protectionStatus = b.getShort();
59 
+        objectCompressedSize = b.getInt();
60 
+        thumbFormat = b.getShort();
61 
+        thumbCompressedSize = b.getInt();
62 
+        thumbPixWidth = b.getInt();
63 
+        thumbPixHeight = b.getInt();
64 
+        imagePixWidth = b.getInt();
65 
+        imagePixHeight = b.getInt();
66 
+        imageBitDepth = b.getInt();
67 
+        parentObject = b.getInt();
68 
+        associationType = b.getShort();
69 
+        associationDesc = b.getInt();
70 
+        sequenceNumber = b.getInt();
71 
+        filename = PacketUtil.readString(b);
72 
+        captureDate = PacketUtil.readString(b);
73 
+        modificationDate = PacketUtil.readString(b);
74 
+        keywords = b.get(); // string, not used on camera?
75 
+    }
76 
+
77 
+    @Override
78 
+    public String toString() {
79 
+        StringBuilder b = new StringBuilder();
80 
+        b.append("ObjectInfo\n");
81 
+        b.append("StorageId: ").append(String.format("0x%08x\n", storageId));
82 
+        b.append("ObjectFormat: ").append(PtpConstants.objectFormatToString(objectFormat)).append('\n');
83 
+        b.append("ProtectionStatus: ").append(protectionStatus).append('\n');
84 
+        b.append("ObjectCompressedSize: ").append(objectCompressedSize).append('\n');
85 
+        b.append("ThumbFormat: ").append(PtpConstants.objectFormatToString(thumbFormat)).append('\n');
86 
+        b.append("ThumbCompressedSize: ").append(thumbCompressedSize).append('\n');
87 
+        b.append("ThumbPixWdith: ").append(thumbPixWidth).append('\n');
88 
+        b.append("ThumbPixHeight: ").append(thumbPixHeight).append('\n');
89 
+        b.append("ImagePixWidth: ").append(imagePixWidth).append('\n');
90 
+        b.append("ImagePixHeight: ").append(imagePixHeight).append('\n');
91 
+        b.append("ImageBitDepth: ").append(imageBitDepth).append('\n');
92 
+        b.append("ParentObject: ").append(String.format("0x%08x", parentObject)).append('\n');
93 
+        b.append("AssociationType: ").append(associationType).append('\n');
94 
+        b.append("AssociatonDesc: ").append(associationDesc).append('\n');
95 
+        b.append("Filename: ").append(filename).append('\n');
96 
+        b.append("CaptureDate: ").append(captureDate).append('\n');
97 
+        b.append("ModificationDate: ").append(modificationDate).append('\n');
98 
+        b.append("Keywords: ").append(keywords).append('\n');
99 
+        return b.toString();
100 
+    }
101 
+}

+ 47 - 0
app/src/main/java/com/remoteyourcam/usb/ptp/model/StorageInfo.java
Преглед на файла 

@@ -0,0 +1,47 @@
1 
+/**
2 
+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech
3 
+ *
4 
+ * Licensed under the Apache License, Version 2.0 (the "License");
5 
+ * you may not use this file except in compliance with the License.
6 
+ * You may obtain a copy of the License at
7 
+ *
8 
+ *     http://www.apache.org/licenses/LICENSE-2.0
9 
+ *
10 
+ * Unless required by applicable law or agreed to in writing, software
11 
+ * distributed under the License is distributed on an "AS IS" BASIS,
12 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 
+ * See the License for the specific language governing permissions and
14 
+ * limitations under the License.
15 
+ */
16 
+package com.remoteyourcam.usb.ptp.model;
17 
+
18 
+import java.nio.ByteBuffer;
19 
+
20 
+import com.remoteyourcam.usb.ptp.PacketUtil;
21 
+
22 
+public class StorageInfo {
23 
+
24 
+    public int storageType;
25 
+    public int filesystemType;
26 
+    public int accessCapability;
27 
+    public long maxCapacity;
28 
+    public long freeSpaceInBytes;
29 
+    public int freeSpaceInImages;
30 
+    public String storageDescription;
31 
+    public String volumeLabel;
32 
+
33 
+    public StorageInfo(ByteBuffer b, int length) {
34 
+        decode(b, length);
35 
+    }
36 
+
37 
+    private void decode(ByteBuffer b, int length) {
38 
+        storageType = b.getShort() & 0xffff;
39 
+        filesystemType = b.getShort() & 0xffff;
40 
+        accessCapability = b.getShort() & 0xff;
41 
+        maxCapacity = b.getLong();
42 
+        freeSpaceInBytes = b.getLong();
43 
+        freeSpaceInImages = b.getInt();
44 
+        storageDescription = PacketUtil.readString(b);
45 
+        volumeLabel = PacketUtil.readString(b);
46 
+    }
47 
+}

kodo - Gogs: Go Git Service
Home Explore Help
Register Sign In
Kodo
/
kodo
Watch 2
Star 0
Fork 0
Issues 0 Pull Requests 0 Commits 1849 Releases 0

No Description

ZIP TAR.GZ
huangqimin001: e9c4ba1497 :art: Opt year data 2 years ago
..
migrations 96c4bec605 :art: Add api activity_group_share 5 years ago
__init__.py 44a6cdf337 Statistic 8 years ago
admin.py 78739fe7d3 KeyError 7 years ago
apps.py 44a6cdf337 Statistic 8 years ago
models.py 88b564d033 fix coercing to Unicode: need string or buffer, long found 5 years ago
tests.py 44a6cdf337 Statistic 8 years ago
views.py e9c4ba1497 :art: Opt year data 2 years ago
pai2 - Gogs: Go Git Service
首页 探索 帮助
注册 登录
Pai2
/
pai2
关注 2
点赞 0
派生 0
工单管理 0 合并请求 0 提交历史 442 版本发布 0

拍爱

ZIP TAR.GZ
Brightcells: 2eba3ed7f9 Add guest login for tourguide 9 年之前
..
0001_initial.py 30daca135b add api message_list_api/message_type_list_api/message_read_api 10 年之前
0002_auto_20160120_1830.py a121b75ff2 add db_index=True for status field 10 年之前
0003_systemmessageinfo_systemmessagereadinfo.py 165424743a modify message relative apis 10 年之前
0004_systemmessagedeleteinfo.py 165424743a modify message relative apis 10 年之前
0005_auto_20160422_1322.py 102152ca4a add api lensman_photo_bought & modify api wx_order_create_api and adjust return field 10 年之前
0006_systemmessageinfo_src.py ee7388cd15 add src for SystemMessageInfo 9 年之前
0007_auto_20160907_1740.py 27d3ec8fb1 add src for LatestAppInfo/SplashInfo 9 年之前
0008_auto_20170315_2243.py 2eba3ed7f9 Add guest login for tourguide 9 年之前
__init__.py 30daca135b add api message_list_api/message_type_list_api/message_read_api 10 年之前