+/**

+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech

+ *

+ * Licensed under the Apache License, Version 2.0 (the "License");

+ * you may not use this file except in compliance with the License.

+ * You may obtain a copy of the License at

+ *

+ *     http://www.apache.org/licenses/LICENSE-2.0

+ *

+ * Unless required by applicable law or agreed to in writing, software

+ * distributed under the License is distributed on an "AS IS" BASIS,

+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

+ * See the License for the specific language governing permissions and

+ * limitations under the License.

+ */

+package com.remoteyourcam.usb.ptp;

+

+import com.remoteyourcam.usb.ptp.Camera.CameraListener;

+

+import android.content.Context;

+import android.content.Intent;

+

+public interface PtpService {

+

+    void setCameraListener(CameraListener listener);

+

+    void initialize(Context context, Intent intent);

+

+    void shutdown();

+

+    void lazyShutdown();

+

+    public static class Singleton {

+        private static PtpService singleton;

+

+        public static PtpService getInstance(Context context) {

+            if (singleton == null) {

+                singleton = new PtpUsbService(context);

+            }

+            return singleton;

+        }

+

+        public static void setInstance(PtpService service) {

+            singleton = service;

+        }

+    }

+}

+/**

+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech

+ *

+ * Licensed under the Apache License, Version 2.0 (the "License");

+ * you may not use this file except in compliance with the License.

+ * You may obtain a copy of the License at

+ *

+ *     http://www.apache.org/licenses/LICENSE-2.0

+ *

+ * Unless required by applicable law or agreed to in writing, software

+ * distributed under the License is distributed on an "AS IS" BASIS,

+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

+ * See the License for the specific language governing permissions and

+ * limitations under the License.

+ */

+package com.remoteyourcam.usb.ptp;

+

+import android.hardware.usb.UsbDeviceConnection;

+import android.hardware.usb.UsbEndpoint;

+import android.hardware.usb.UsbRequest;

+

+public class PtpUsbConnection {

+

+    private final UsbDeviceConnection connection;

+    private final UsbEndpoint bulkOut;

+    private final UsbEndpoint bulkIn;

+    private final int vendorId;

+    private final int productId;

+

+    public PtpUsbConnection(UsbDeviceConnection connection, UsbEndpoint bulkIn, UsbEndpoint bulkOut, int vendorId,

+            int productId) {

+        this.connection = connection;

+        this.bulkIn = bulkIn;

+        this.bulkOut = bulkOut;

+        this.vendorId = vendorId;

+        this.productId = productId;

+    }

+

+    public int getVendorId() {

+        return vendorId;

+    }

+

+    public int getProductId() {

+        return productId;

+    }

+

+    public void close() {

+        connection.close();

+    }

+

+    public int getMaxPacketInSize() {

+        return bulkIn.getMaxPacketSize();

+    }

+

+    public int getMaxPacketOutSize() {

+        return bulkOut.getMaxPacketSize();

+    }

+

+    public UsbRequest createInRequest() {

+        UsbRequest r = new UsbRequest();

+        r.initialize(connection, bulkIn);

+        return r;

+    }

+

+    public int bulkTransferOut(byte[] buffer, int length, int timeout) {

+        return connection.bulkTransfer(bulkOut, buffer, length, timeout);

+    }

+

+    public int bulkTransferIn(byte[] buffer, int maxLength, int timeout) {

+        return connection.bulkTransfer(bulkIn, buffer, maxLength, timeout);

+    }

+

+    public void requestWait() {

+        connection.requestWait();

+    }

+}

+/**

+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech

+ *

+ * Licensed under the Apache License, Version 2.0 (the "License");

+ * you may not use this file except in compliance with the License.

+ * You may obtain a copy of the License at

+ *

+ *     http://www.apache.org/licenses/LICENSE-2.0

+ *

+ * Unless required by applicable law or agreed to in writing, software

+ * distributed under the License is distributed on an "AS IS" BASIS,

+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

+ * See the License for the specific language governing permissions and

+ * limitations under the License.

+ */

+package com.remoteyourcam.usb.ptp;

+

+import java.util.Map;

+

+import android.app.PendingIntent;

+import android.content.BroadcastReceiver;

+import android.content.Context;

+import android.content.Intent;

+import android.content.IntentFilter;

+import android.hardware.usb.UsbConstants;

+import android.hardware.usb.UsbDevice;

+import android.hardware.usb.UsbEndpoint;

+import android.hardware.usb.UsbInterface;

+import android.hardware.usb.UsbManager;

+import android.os.Handler;

+import android.util.Log;

+

+import com.remoteyourcam.usb.AppConfig;

+import com.remoteyourcam.usb.ptp.Camera.CameraListener;

+import com.remoteyourcam.usb.ptp.PtpCamera.State;

+

+public class PtpUsbService implements PtpService {

+

+    private final String TAG = PtpUsbService.class.getSimpleName();

+

+    private static final String ACTION_USB_PERMISSION = "com.android.example.USB_PERMISSION";

+    private final BroadcastReceiver permissonReceiver = new BroadcastReceiver() {

+        @Override

+        public void onReceive(Context context, Intent intent) {

+            String action = intent.getAction();

+            if (ACTION_USB_PERMISSION.equals(action)) {

+                unregisterPermissionReceiver(context);

+                synchronized (this) {

+                    UsbDevice device = (UsbDevice) intent.getParcelableExtra(UsbManager.EXTRA_DEVICE);

+

+                    if (intent.getBooleanExtra(UsbManager.EXTRA_PERMISSION_GRANTED, false)) {

+                        connect(context, device);

+                    } else {

+                        //TODO report

+                    }

+                }

+            }

+        }

+    };

+

+    private final Handler handler = new Handler();

+    private final UsbManager usbManager;

+    private PtpCamera camera;

+    private CameraListener listener;

+

+    Runnable shutdownRunnable = new Runnable() {

+        @Override

+        public void run() {

+            shutdown();

+        }

+    };

+

+    public PtpUsbService(Context context) {

+        this.usbManager = (UsbManager) context.getSystemService(Context.USB_SERVICE);

+    }

+

+    @Override

+    public void setCameraListener(CameraListener listener) {

+        this.listener = listener;

+        if (camera != null) {

+            camera.setListener(listener);

+        }

+    }

+

+    @Override

+    public void initialize(Context context, Intent intent) {

+        handler.removeCallbacks(shutdownRunnable);

+        if (camera != null) {

+            if (AppConfig.LOG) {

+                Log.i(TAG, "initialize: camera available");

+                listener.onLogMessage("有可用相机，初始化中");

+            }

+            if (camera.getState() == State.Active) {

+                if (listener != null) {

+                    listener.onCameraStarted(camera);

+                }

+                return;

+            }

+            if (AppConfig.LOG) {

+                Log.i(TAG, "initialize: camera not active, satet " + camera.getState());

+            }

+            camera.shutdownHard();

+        }

+        UsbDevice device = (UsbDevice) intent.getParcelableExtra(UsbManager.EXTRA_DEVICE);

+        if (device != null) {

+            if (AppConfig.LOG) {

+                Log.i(TAG, "initialize: got device through intent");

+                listener.onLogMessage("发现可用相机设备"+device.getDeviceName());

+            }

+            connect(context, device);

+        } else {

+            if (AppConfig.LOG) {

+                Log.i(TAG, "initialize: looking for compatible camera");

+                listener.onLogMessage("查找相机设备...");

+            }

+            device = lookupCompatibleDevice(usbManager);

+            if (device != null) {

+                listener.onLogMessage("查找到相机设备"+device.getDeviceName());

+                registerPermissionReceiver(context);

+                PendingIntent mPermissionIntent = PendingIntent.getBroadcast(context, 0, new Intent(

+                        ACTION_USB_PERMISSION), 0);

+                usbManager.requestPermission(device, mPermissionIntent);

+            } else {

+                listener.onNoCameraFound();

+            }

+        }

+    }

+

+    @Override

+    public void shutdown() {

+        if (AppConfig.LOG) {

+            Log.i(TAG, "shutdown");

+            listener.onLogMessage("关闭设备");

+        }

+        if (camera != null) {

+            camera.shutdown();

+            camera = null;

+        }

+    }

+

+    @Override

+    public void lazyShutdown() {

+        if (AppConfig.LOG) {

+            Log.i(TAG, "lazy shutdown");

+        }

+        handler.postDelayed(shutdownRunnable, 4000);

+    }

+

+    private void registerPermissionReceiver(Context context) {

+        if (AppConfig.LOG) {

+            Log.i(TAG, "register permission receiver");

+        }

+        IntentFilter filter = new IntentFilter(ACTION_USB_PERMISSION);

+        context.registerReceiver(permissonReceiver, filter);

+    }

+

+    private void unregisterPermissionReceiver(Context context) {

+        if (AppConfig.LOG) {

+            Log.i(TAG, "unregister permission receiver");

+        }

+        context.unregisterReceiver(permissonReceiver);

+    }

+

+    private UsbDevice lookupCompatibleDevice(UsbManager manager) {

+        Map<String, UsbDevice> deviceList = manager.getDeviceList();

+        for (Map.Entry<String, UsbDevice> e : deviceList.entrySet()) {

+            UsbDevice d = e.getValue();

+            if (d.getVendorId() == PtpConstants.CanonVendorId || d.getVendorId() == PtpConstants.NikonVendorId) {

+                return d;

+            }

+        }

+        return null;

+    }

+

+    private boolean connect(Context context, UsbDevice device) {

+        if (camera != null) {

+            camera.shutdown();

+            camera = null;

+        }

+        for (int i = 0, n = device.getInterfaceCount(); i < n; ++i) {

+            UsbInterface intf = device.getInterface(i);

+

+            if (intf.getEndpointCount() != 3) {

+                continue;

+            }

+

+            UsbEndpoint in = null;

+            UsbEndpoint out = null;

+

+            for (int e = 0, en = intf.getEndpointCount(); e < en; ++e) {

+                UsbEndpoint endpoint = intf.getEndpoint(e);

+                if (endpoint.getType() == UsbConstants.USB_ENDPOINT_XFER_BULK) {

+                    if (endpoint.getDirection() == UsbConstants.USB_DIR_IN) {

+                        in = endpoint;

+                    } else if (endpoint.getDirection() == UsbConstants.USB_DIR_OUT) {

+                        out = endpoint;

+                    }

+                }

+            }

+

+            if (in == null || out == null) {

+                continue;

+            }

+

+            if (AppConfig.LOG) {

+                Log.i(TAG, "Found compatible USB interface");

+                Log.i(TAG, "Interface class " + intf.getInterfaceClass());

+                Log.i(TAG, "Interface subclass " + intf.getInterfaceSubclass());

+                Log.i(TAG, "Interface protocol " + intf.getInterfaceProtocol());

+                Log.i(TAG, "Bulk out max size " + out.getMaxPacketSize());

+                Log.i(TAG, "Bulk in max size " + in.getMaxPacketSize());

+                listener.onLogMessage("发现兼容的USB接口设备 "+ device.getDeviceName() +" "+  device.getVendorId());

+            }

+

+            if (device.getVendorId() == PtpConstants.CanonVendorId) {

+                PtpUsbConnection connection = new PtpUsbConnection(usbManager.openDevice(device), in, out,

+                        device.getVendorId(), device.getProductId());

+                camera = new EosCamera(connection, listener, new WorkerNotifier(context));

+            } else if (device.getVendorId() == PtpConstants.NikonVendorId) {

+                PtpUsbConnection connection = new PtpUsbConnection(usbManager.openDevice(device), in, out,

+                        device.getVendorId(), device.getProductId());

+                camera = new NikonCamera(connection, listener, new WorkerNotifier(context));

+            }

+

+            return true;

+        }

+

+        if (listener != null) {

+            listener.onError("No compatible camera found");

+        }

+

+        return false;

+    }

+}

+/**

+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech

+ *

+ * Licensed under the Apache License, Version 2.0 (the "License");

+ * you may not use this file except in compliance with the License.

+ * You may obtain a copy of the License at

+ *

+ *     http://www.apache.org/licenses/LICENSE-2.0

+ *

+ * Unless required by applicable law or agreed to in writing, software

+ * distributed under the License is distributed on an "AS IS" BASIS,

+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

+ * See the License for the specific language governing permissions and

+ * limitations under the License.

+ */

+package com.remoteyourcam.usb.ptp;

+

+import android.content.Context;

+

+public class WorkerNotifier implements Camera.WorkerListener {

+

+

+    public WorkerNotifier(Context context) {

+    }

+

+    @Override

+    public void onWorkerStarted() {

+    }

+

+    @Override

+    public void onWorkerEnded() {

+    }

+

+}

+/**

+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech

+ *

+ * Licensed under the Apache License, Version 2.0 (the "License");

+ * you may not use this file except in compliance with the License.

+ * You may obtain a copy of the License at

+ *

+ *     http://www.apache.org/licenses/LICENSE-2.0

+ *

+ * Unless required by applicable law or agreed to in writing, software

+ * distributed under the License is distributed on an "AS IS" BASIS,

+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

+ * See the License for the specific language governing permissions and

+ * limitations under the License.

+ */

+package com.remoteyourcam.usb.ptp.commands;

+

+import java.nio.ByteBuffer;

+

+import com.remoteyourcam.usb.AppConfig;

+import com.remoteyourcam.usb.ptp.PtpCamera;

+import com.remoteyourcam.usb.ptp.PtpConstants;

+import com.remoteyourcam.usb.ptp.PtpCamera.IO;

+import com.remoteyourcam.usb.ptp.PtpConstants.Operation;

+import com.remoteyourcam.usb.ptp.PtpConstants.Response;

+

+import android.util.Log;

+

+public class CloseSessionCommand extends Command {

+

+    private final String TAG = CloseSessionCommand.class.getSimpleName();

+

+    public CloseSessionCommand(PtpCamera camera) {

+        super(camera);

+    }

+

+    @Override

+    public void exec(IO io) {

+        io.handleCommand(this);

+        // Can this even happen?

+        if (responseCode == Response.DeviceBusy) {

+            camera.onDeviceBusy(this, true);

+            return;

+        }

+        // close even when error happened

+        camera.onSessionClosed();

+        if (responseCode != Response.Ok) {

+            // TODO error report

+            if (AppConfig.LOG) {

+                Log.w(TAG,

+                        String.format("Error response when closing session, response %s",

+                                PtpConstants.responseToString(responseCode)));

+            }

+        }

+    }

+

+    @Override

+    public void encodeCommand(ByteBuffer b) {

+        encodeCommand(b, Operation.CloseSession);

+    }

+}

+/**

+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech

+ *

+ * Licensed under the Apache License, Version 2.0 (the "License");

+ * you may not use this file except in compliance with the License.

+ * You may obtain a copy of the License at

+ *

+ *     http://www.apache.org/licenses/LICENSE-2.0

+ *

+ * Unless required by applicable law or agreed to in writing, software

+ * distributed under the License is distributed on an "AS IS" BASIS,

+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

+ * See the License for the specific language governing permissions and

+ * limitations under the License.

+ */

+package com.remoteyourcam.usb.ptp.commands;

+

+import android.util.Log;

+

+import com.remoteyourcam.usb.AppConfig;

+import com.remoteyourcam.usb.ptp.PacketUtil;

+import com.remoteyourcam.usb.ptp.PtpAction;

+import com.remoteyourcam.usb.ptp.PtpCamera;

+import com.remoteyourcam.usb.ptp.PtpConstants;

+import com.remoteyourcam.usb.ptp.PtpConstants.Type;

+

+import java.nio.ByteBuffer;

+

+/**

+ * Base class for all PTP commands.

+ */

+public abstract class Command implements PtpAction {

+

+    private static final String TAG = "Command";

+

+    protected final PtpCamera camera;

+

+    /**

+     * Deriving classes have to set this field to true if they want to send data

+     * from host to camera.

+     */

+    protected boolean hasDataToSend;

+

+    /**

+     * Received response code, should be handled in

+     * {@link #exec(com.remoteyourcam.usb.ptp.PtpCamera.IO)}.

+     */

+    protected int responseCode;

+

+    private boolean hasResponseReceived;

+

+    public Command(PtpCamera camera) {

+        this.camera = camera;

+    }

+

+    @Override

+    public abstract void exec(PtpCamera.IO io);

+

+    public abstract void encodeCommand(ByteBuffer b);

+

+    /**

+     * Derived classes should implement this method if they want to send data

+     * from host to camera. The field {@code hasDataToSend} has to be set to

+     * true for the sending to be done. The data to send must not be greater

+     * than the USB max packet size, any size below 256 should be save.

+     */

+    public void encodeData(ByteBuffer b) {

+    }

+

+    /**

+     * Derived classes should implement this method if they want to decode data

+     * received in an data packet that has been sent by the camera. The

+     * {@code ByteBuffer} already points to the first byte behind the

+     * transaction id, i.e. the payload.

+     */

+    protected void decodeData(ByteBuffer b, int length) {

+        if (AppConfig.LOG) {

+            Log.w(TAG, "Received data packet but handler not implemented");

+        }

+    }

+

+    /**

+     * Override if any special response data has to be decoded. The

+     * {@code ByteBuffer} already points to the first byte behind the

+     * transaction id, i.e. the payload.

+     */

+    protected void decodeResponse(ByteBuffer b, int length) {

+    }

+

+    public boolean hasDataToSend() {

+        return hasDataToSend;

+    }

+

+    public boolean hasResponseReceived() {

+        return hasResponseReceived;

+    }

+

+    public int getResponseCode() {

+        return responseCode;

+    }

+

+    public void receivedRead(ByteBuffer b) {

+        int length = b.getInt();

+        int type = b.getShort() & 0xFFFF;

+        int code = b.getShort() & 0xFFFF;

+        int tx = b.getInt();

+

+        if (AppConfig.LOG) {

+            Log.i(TAG,

+                    String.format("Received %s packet for %s, length %d, code %s, tx %d",

+                            PtpConstants.typeToString(type), getClass().getSimpleName(), length,

+                            PtpConstants.codeToString(type, code), tx));

+        }

+        if (AppConfig.LOG_PACKETS) {

+            PacketUtil.logHexdump(TAG, b.array(), length < 512 ? length : 512);

+        }

+

+        if (type == Type.Data) {

+            decodeData(b, length);

+        } else if (type == Type.Response) {

+            hasResponseReceived = true;

+            responseCode = code;

+            decodeResponse(b, length);

+        } else {

+            // error

+            hasResponseReceived = true;

+        }

+    }

+

+    /**

+     * Reset fields so this command may be requeued.

+     */

+    @Override

+    public void reset() {

+        responseCode = 0;

+        hasResponseReceived = false;

+    }

+

+    protected void encodeCommand(ByteBuffer b, int code) {

+        b.putInt(12);

+        b.putShort((short) Type.Command);

+        b.putShort((short) code);

+        b.putInt(camera.nextTransactionId());

+        if (AppConfig.LOG_PACKETS) {

+            Log.i(TAG, "command packet for " + getClass().getSimpleName());

+            PacketUtil.logHexdump(TAG, b.array(), 12);

+        }

+    }

+

+    protected void encodeCommand(ByteBuffer b, int code, int p0) {

+        b.putInt(16);

+        b.putShort((short) Type.Command);

+        b.putShort((short) code);

+        b.putInt(camera.nextTransactionId());

+        b.putInt(p0);

+        if (AppConfig.LOG_PACKETS) {

+            Log.i(TAG, "command packet for " + getClass().getSimpleName());

+            PacketUtil.logHexdump(TAG, b.array(), 16);

+        }

+    }

+

+    protected void encodeCommand(ByteBuffer b, int code, int p0, int p1) {

+        b.putInt(20);

+        b.putShort((short) Type.Command);

+        b.putShort((short) code);

+        b.putInt(camera.nextTransactionId());

+        b.putInt(p0);

+        b.putInt(p1);

+        if (AppConfig.LOG_PACKETS) {

+            Log.i(TAG, "command packet for " + getClass().getSimpleName());

+            PacketUtil.logHexdump(TAG, b.array(), 20);

+        }

+    }

+

+    protected void encodeCommand(ByteBuffer b, int code, int p0, int p1, int p2) {

+        b.putInt(24);

+        b.putShort((short) Type.Command);

+        b.putShort((short) code);

+        b.putInt(camera.nextTransactionId());

+        b.putInt(p0);

+        b.putInt(p1);

+        b.putInt(p2);

+        if (AppConfig.LOG_PACKETS) {

+            Log.i(TAG, "command packet for " + getClass().getSimpleName());

+            PacketUtil.logHexdump(TAG, b.array(), 24);

+        }

+    }

+}

+/**

+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech

+ *

+ * Licensed under the Apache License, Version 2.0 (the "License");

+ * you may not use this file except in compliance with the License.

+ * You may obtain a copy of the License at

+ *

+ *     http://www.apache.org/licenses/LICENSE-2.0

+ *

+ * Unless required by applicable law or agreed to in writing, software

+ * distributed under the License is distributed on an "AS IS" BASIS,

+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

+ * See the License for the specific language governing permissions and

+ * limitations under the License.

+ */

+package com.remoteyourcam.usb.ptp.commands;

+

+import java.nio.ByteBuffer;

+

+import com.remoteyourcam.usb.ptp.PtpCamera;

+import com.remoteyourcam.usb.ptp.PtpConstants;

+import com.remoteyourcam.usb.ptp.PtpCamera.IO;

+import com.remoteyourcam.usb.ptp.PtpConstants.Operation;

+import com.remoteyourcam.usb.ptp.PtpConstants.Response;

+import com.remoteyourcam.usb.ptp.model.DeviceInfo;

+

+public class GetDeviceInfoCommand extends Command {

+

+    private DeviceInfo info;

+

+    public GetDeviceInfoCommand(PtpCamera camera) {

+        super(camera);

+    }

+

+    @Override

+    public void exec(IO io) {

+        io.handleCommand(this);

+        if (responseCode != Response.Ok) {

+            camera.onPtpError(String.format("Couldn't read device information, error code \"%s\"",

+                    PtpConstants.responseToString(responseCode)));

+        } else if (info == null) {

+            camera.onPtpError("Couldn't retrieve device information");

+        }

+    }

+

+    @Override

+    public void reset() {

+        super.reset();

+        info = null;

+    }

+

+    @Override

+    public void encodeCommand(ByteBuffer b) {

+        encodeCommand(b, Operation.GetDeviceInfo);

+    }

+

+    @Override

+    protected void decodeData(ByteBuffer b, int length) {

+        info = new DeviceInfo(b, length);

+        camera.setDeviceInfo(info);

+    }

+}

+/**

+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech

+ *

+ * Licensed under the Apache License, Version 2.0 (the "License");

+ * you may not use this file except in compliance with the License.

+ * You may obtain a copy of the License at

+ *

+ *     http://www.apache.org/licenses/LICENSE-2.0

+ *

+ * Unless required by applicable law or agreed to in writing, software

+ * distributed under the License is distributed on an "AS IS" BASIS,

+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

+ * See the License for the specific language governing permissions and

+ * limitations under the License.

+ */

+package com.remoteyourcam.usb.ptp.commands;

+

+import java.nio.ByteBuffer;

+

+import com.remoteyourcam.usb.ptp.PtpCamera;

+import com.remoteyourcam.usb.ptp.PtpCamera.IO;

+import com.remoteyourcam.usb.ptp.PtpConstants;

+import com.remoteyourcam.usb.ptp.model.DevicePropDesc;

+

+public class GetDevicePropDescCommand extends Command {

+

+    private final int property;

+    private DevicePropDesc devicePropDesc;

+

+    public GetDevicePropDescCommand(PtpCamera camera, int property) {

+        super(camera);

+        this.property = property;

+    }

+

+    @Override

+    public void exec(IO io) {

+        io.handleCommand(this);

+        if (responseCode == PtpConstants.Response.DeviceBusy) {

+            camera.onDeviceBusy(this, true);

+        }

+        if (devicePropDesc != null) {

+            // this order is important

+            camera.onPropertyDescChanged(property, devicePropDesc);

+            camera.onPropertyChanged(property, devicePropDesc.currentValue);

+        }

+    }

+

+    @Override

+    public void encodeCommand(ByteBuffer b) {

+        encodeCommand(b, PtpConstants.Operation.GetDevicePropDesc, property);

+    }

+

+    @Override

+    protected void decodeData(ByteBuffer b, int length) {

+        devicePropDesc = new DevicePropDesc(b, length);

+    }

+}

+/**

+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech

+ *

+ * Licensed under the Apache License, Version 2.0 (the "License");

+ * you may not use this file except in compliance with the License.

+ * You may obtain a copy of the License at

+ *

+ *     http://www.apache.org/licenses/LICENSE-2.0

+ *

+ * Unless required by applicable law or agreed to in writing, software

+ * distributed under the License is distributed on an "AS IS" BASIS,

+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

+ * See the License for the specific language governing permissions and

+ * limitations under the License.

+ */

+package com.remoteyourcam.usb.ptp.commands;

+

+import java.nio.ByteBuffer;

+

+import com.remoteyourcam.usb.ptp.PtpCamera;

+import com.remoteyourcam.usb.ptp.PtpCamera.IO;

+import com.remoteyourcam.usb.ptp.PtpConstants;

+import com.remoteyourcam.usb.ptp.PtpConstants.Datatype;

+import com.remoteyourcam.usb.ptp.PtpConstants.Response;

+

+public class GetDevicePropValueCommand extends Command {

+

+    private final int property;

+    private final int datatype;

+    private int value;

+

+    public GetDevicePropValueCommand(PtpCamera camera, int property, int datatype) {

+        super(camera);

+        this.property = property;

+        this.datatype = datatype;

+    }

+

+    @Override

+    public void exec(IO io) {

+        io.handleCommand(this);

+        if (responseCode == Response.DeviceBusy) {

+            camera.onDeviceBusy(this, true);

+        }

+        if (responseCode == Response.Ok) {

+            camera.onPropertyChanged(property, value);

+        }

+    }

+

+    @Override

+    public void encodeCommand(ByteBuffer b) {

+        encodeCommand(b, PtpConstants.Operation.GetDevicePropValue, property);

+    }

+

+    @Override

+    protected void decodeData(ByteBuffer b, int length) {

+        if (datatype == Datatype.int8) {

+            value = b.get();

+        } else if (datatype == Datatype.uint8) {

+            value = b.get() & 0xFF;

+        } else if (datatype == Datatype.uint16) {

+            value = b.getShort() & 0xFFFF;

+        } else if (datatype == Datatype.int16) {

+            value = b.getShort();

+        } else if (datatype == Datatype.int32 || datatype == Datatype.uint32) {

+            value = b.getInt();

+        }

+    }

+}

+/**

+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech

+ *

+ * Licensed under the Apache License, Version 2.0 (the "License");

+ * you may not use this file except in compliance with the License.

+ * You may obtain a copy of the License at

+ *

+ *     http://www.apache.org/licenses/LICENSE-2.0

+ *

+ * Unless required by applicable law or agreed to in writing, software

+ * distributed under the License is distributed on an "AS IS" BASIS,

+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

+ * See the License for the specific language governing permissions and

+ * limitations under the License.

+ */

+package com.remoteyourcam.usb.ptp.commands;

+

+import java.nio.ByteBuffer;

+

+import android.graphics.Bitmap;

+import android.graphics.BitmapFactory;

+import android.util.Log;

+

+import com.remoteyourcam.usb.ptp.PtpCamera;

+import com.remoteyourcam.usb.ptp.PtpCamera.IO;

+import com.remoteyourcam.usb.ptp.PtpConstants;

+

+/**

+ * Read file data from camera with specified {@code objectHandle}.

+ */

+public class GetObjectCommand extends Command {

+

+    private static final String TAG = GetObjectCommand.class.getSimpleName();

+

+    private final int objectHandle;

+

+    private final BitmapFactory.Options options;

+    private Bitmap inBitmap;

+

+    private boolean outOfMemoryError;

+

+    public GetObjectCommand(PtpCamera camera, int objectHandle, int sampleSize) {

+        super(camera);

+        this.objectHandle = objectHandle;

+        options = new BitmapFactory.Options();

+        if (sampleSize >= 1 && sampleSize <= 4) {

+            options.inSampleSize = sampleSize;

+        } else {

+            options.inSampleSize = 2;

+        }

+    }

+

+    public Bitmap getBitmap() {

+        return inBitmap;

+    }

+

+    public boolean isOutOfMemoryError() {

+        return outOfMemoryError;

+    }

+

+    @Override

+    public void exec(IO io) {

+        throw new UnsupportedOperationException();

+    }

+

+    @Override

+    public void reset() {

+        super.reset();

+        inBitmap = null;

+        outOfMemoryError = false;

+    }

+

+    @Override

+    public void encodeCommand(ByteBuffer b) {

+        encodeCommand(b, PtpConstants.Operation.GetObject, objectHandle);

+    }

+

+    @Override

+    protected void decodeData(ByteBuffer b, int length) {

+        try {

+            // 12 == offset of data header

+            inBitmap = BitmapFactory.decodeByteArray(b.array(), 12, length - 12, options);

+        } catch (RuntimeException e) {

+            Log.i(TAG, "exception on decoding picture : " + e.toString());

+        } catch (OutOfMemoryError e) {

+            System.gc();

+            outOfMemoryError = true;

+        }

+    }

+}

+/**

+ * Copyright 2013 Nils Assbeck, Guersel Ayaz and Michael Zoech

+ *

+ * Licensed under the Apache License, Version 2.0 (the "License");

+ * you may not use this file except in compliance with the License.

+ * You may obtain a copy of the License at

+ *

+ *     http://www.apache.org/licenses/LICENSE-2.0

+ *

+ * Unless required by applicable law or agreed to in writing, software

+ * distributed under the License is distributed on an "AS IS" BASIS,

+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

+ * See the License for the specific language governing permissions and

+ * limitations under the License.

+ */

+package com.remoteyourcam.usb.ptp.commands;

+

+import java.nio.ByteBuffer;

+

+import com.remoteyourcam.usb.ptp.Camera.StorageInfoListener;

+import com.remoteyourcam.usb.ptp.PacketUtil;

+import com.remoteyourcam.usb.ptp.PtpCamera;

+import com.remoteyourcam.usb.ptp.PtpCamera.IO;

+import com.remoteyourcam.usb.ptp.PtpConstants;

+import com.remoteyourcam.usb.ptp.PtpConstants.Response;

+

+public class GetObjectHandlesCommand extends Command {

+

+    private final int storageId;

+    private final int objectFormat;

+    private final int associationHandle;

+    private int[] objectHandles;

+    private final StorageInfoListener listener;

+

+    public int[] getObjectHandles() {

+        if (objectHandles == null) {

+            return new int[0];

+        }

+        return objectHandles;

+    }

+

+    public GetObjectHandlesCommand(PtpCamera camera, StorageInfoListener listener, int storageId) {

+        this(camera, listener, storageId, 0, 0);

+    }

+

+    public GetObjectHandlesCommand(PtpCamera camera, StorageInfoListener listener, int storageId, int objectFormat) {

+        this(camera, listener, storageId, objectFormat, 0);

+    }

+

+    public GetObjectHandlesCommand(PtpCamera camera, StorageInfoListener listener, int storageId, int objectFormat,

+            int associationHandle) {

+        super(camera);

+        this.listener = listener;

+        this.storageId = storageId;

+        this.objectFormat = objectFormat;

+        this.associationHandle = associationHandle;

+    }

+

+    @Override