/*
* Copyright (C) 2010 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.camerabrowser;
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.UsbDeviceConnection;
import android.hardware.usb.UsbInterface;
import android.hardware.usb.UsbManager;
import android.mtp.MtpDevice;
import android.mtp.MtpDeviceInfo;
import android.mtp.MtpObjectInfo;
import android.mtp.MtpStorageInfo;
import android.os.ParcelFileDescriptor;
import android.util.Log;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
/**
* This class helps an application manage a list of connected MTP or PTP devices.
* It listens for MTP devices being attached and removed from the USB host bus
* and notifies the application when the MTP device list changes.
*/
public class MtpClient {
private static final String TAG = "MtpClient";
private static final String ACTION_USB_PERMISSION =
"android.mtp.MtpClient.action.USB_PERMISSION";
private final Context mContext;
private final UsbManager mUsbManager;
private final ArrayList<Listener> mListeners = new ArrayList<Listener>();
// mDevices contains all MtpDevices that have been seen by our client,
// so we can inform when the device has been detached.
// mDevices is also used for synchronization in this class.
private final HashMap<String, MtpDevice> mDevices = new HashMap<String, MtpDevice>();
private final PendingIntent mPermissionIntent;
private final BroadcastReceiver mUsbReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
String action = intent.getAction();
UsbDevice usbDevice = (UsbDevice)intent.getParcelableExtra(UsbManager.EXTRA_DEVICE);
String deviceName = usbDevice.getDeviceName();
synchronized (mDevices) {
MtpDevice mtpDevice = mDevices.get(deviceName);
if (UsbManager.ACTION_USB_DEVICE_ATTACHED.equals(action)) {
if (mtpDevice == null) {
mtpDevice = openDeviceLocked(usbDevice);
}
if (mtpDevice != null) {
for (Listener listener : mListeners) {
listener.deviceAdded(mtpDevice);
}
}
} else if (UsbManager.ACTION_USB_DEVICE_DETACHED.equals(action)) {
if (mtpDevice != null) {
mDevices.remove(deviceName);
for (Listener listener : mListeners) {
listener.deviceRemoved(mtpDevice);
}
}
} else if (ACTION_USB_PERMISSION.equals(action)) {
boolean permission = intent.getBooleanExtra(UsbManager.EXTRA_PERMISSION_GRANTED,
false);
Log.d(TAG, "ACTION_USB_PERMISSION: " + permission);
if (permission) {
if (mtpDevice == null) {
mtpDevice = openDeviceLocked(usbDevice);
}
if (mtpDevice != null) {
for (Listener listener : mListeners) {
listener.deviceAdded(mtpDevice);
}
}
}
}
}
}
};
/**
* An interface for being notified when MTP or PTP devices are attached
* or removed. In the current implementation, only PTP devices are supported.
*/
public interface Listener {
/**
* Called when a new device has been added
*
* @param device the new device that was added
*/
public void deviceAdded(MtpDevice device);
/**
* Called when a new device has been removed
*
* @param device the device that was removed
*/
public void deviceRemoved(MtpDevice device);
}
/**
* Tests to see if a {@link android.hardware.usb.UsbDevice}
* supports the PTP protocol (typically used by digital cameras)
*
* @param device the device to test
* @return true if the device is a PTP device.
*/
static public boolean isCamera(UsbDevice device) {
int count = device.getInterfaceCount();
for (int i = 0; i < count; i++) {
UsbInterface intf = device.getInterface(i);
if (intf.getInterfaceClass() == UsbConstants.USB_CLASS_STILL_IMAGE &&
intf.getInterfaceSubclass() == 1 &&
intf.getInterfaceProtocol() == 1) {
return true;
}
}
return false;
}
/**
* MtpClient constructor
*
* @param context the {@link android.content.Context} to use for the MtpClient
*/
public MtpClient(Context context) {
mContext = context;
mUsbManager = (UsbManager)context.getSystemService(Context.USB_SERVICE);
mPermissionIntent = PendingIntent.getBroadcast(mContext, 0, new Intent(ACTION_USB_PERMISSION), 0);
IntentFilter filter = new IntentFilter();
filter.addAction(UsbManager.ACTION_USB_DEVICE_ATTACHED);
filter.addAction(UsbManager.ACTION_USB_DEVICE_DETACHED);
filter.addAction(ACTION_USB_PERMISSION);
context.registerReceiver(mUsbReceiver, filter);
}
/**
* Opens the {@link android.hardware.usb.UsbDevice} for an MTP or PTP
* device and return an {@link android.mtp.MtpDevice} for it.
*
* @param device the device to open
* @return an MtpDevice for the device.
*/
private MtpDevice openDeviceLocked(UsbDevice usbDevice) {
if (isCamera(usbDevice)) {
if (!mUsbManager.hasPermission(usbDevice)) {
mUsbManager.requestPermission(usbDevice, mPermissionIntent);
} else {
UsbDeviceConnection connection = mUsbManager.openDevice(usbDevice);
if (connection != null) {
MtpDevice mtpDevice = new MtpDevice(usbDevice);
if (mtpDevice.open(connection)) {
mDevices.put(usbDevice.getDeviceName(), mtpDevice);
return mtpDevice;
}
}
}
}
return null;
}
/**
* Closes all resources related to the MtpClient object
*/
public void close() {
mContext.unregisterReceiver(mUsbReceiver);
}
/**
* Registers a {@link android.mtp.MtpClient.Listener} interface to receive
* notifications when MTP or PTP devices are added or removed.
*
* @param listener the listener to register
*/
public void addListener(Listener listener) {
synchronized (mDevices) {
if (!mListeners.contains(listener)) {
mListeners.add(listener);
}
}
}
/**
* Unregisters a {@link android.mtp.MtpClient.Listener} interface.
*
* @param listener the listener to unregister
*/
public void removeListener(Listener listener) {
synchronized (mDevices) {
mListeners.remove(listener);
}
}
/**
* Retrieves an {@link android.mtp.MtpDevice} object for the USB device
* with the given name.
*
* @param deviceName the name of the USB device
* @return the MtpDevice, or null if it does not exist
*/
public MtpDevice getDevice(String deviceName) {
synchronized (mDevices) {
return mDevices.get(deviceName);
}
}
/**
* Retrieves an {@link android.mtp.MtpDevice} object for the USB device
* with the given ID.
*
* @param id the ID of the USB device
* @return the MtpDevice, or null if it does not exist
*/
public MtpDevice getDevice(int id) {
synchronized (mDevices) {
return mDevices.get(UsbDevice.getDeviceName(id));
}
}
/**
* Retrieves a list of all currently connected {@link android.mtp.MtpDevice}.
*
* @return the list of MtpDevices
*/
public List<MtpDevice> getDeviceList() {
synchronized (mDevices) {
// Query the USB manager since devices might have attached
// before we added our listener.
for (UsbDevice usbDevice : mUsbManager.getDeviceList().values()) {
if (mDevices.get(usbDevice.getDeviceName()) == null) {
openDeviceLocked(usbDevice);
}
}
return new ArrayList<MtpDevice>(mDevices.values());
}
}
/**
* Retrieves a list of all {@link android.mtp.MtpStorageInfo}
* for the MTP or PTP device with the given USB device name
*
* @param deviceName the name of the USB device
* @return the list of MtpStorageInfo
*/
public List<MtpStorageInfo> getStorageList(String deviceName) {
MtpDevice device = getDevice(deviceName);
if (device == null) {
return null;
}
int[] storageIds = device.getStorageIds();
if (storageIds == null) {
return null;
}
int length = storageIds.length;
ArrayList<MtpStorageInfo> storageList = new ArrayList<MtpStorageInfo>(length);
for (int i = 0; i < length; i++) {
MtpStorageInfo info = device.getStorageInfo(storageIds[i]);
if (info == null) {
Log.w(TAG, "getStorageInfo failed");
} else {
storageList.add(info);
}
}
return storageList;
}
/**
* Retrieves the {@link android.mtp.MtpObjectInfo} for an object on
* the MTP or PTP device with the given USB device name with the given
* object handle
*
* @param deviceName the name of the USB device
* @param objectHandle handle of the object to query
* @return the MtpObjectInfo
*/
public MtpObjectInfo getObjectInfo(String deviceName, int objectHandle) {
MtpDevice device = getDevice(deviceName);
if (device == null) {
return null;
}
return device.getObjectInfo(objectHandle);
}
/**
* Deletes an object on the MTP or PTP device with the given USB device name.
*
* @param deviceName the name of the USB device
* @param objectHandle handle of the object to delete
* @return true if the deletion succeeds
*/
public boolean deleteObject(String deviceName, int objectHandle) {
MtpDevice device = getDevice(deviceName);
if (device == null) {
return false;
}
return device.deleteObject(objectHandle);
}
/**
* Retrieves a list of {@link android.mtp.MtpObjectInfo} for all objects
* on the MTP or PTP device with the given USB device name and given storage ID
* and/or object handle.
* If the object handle is zero, then all objects in the root of the storage unit
* will be returned. Otherwise, all immediate children of the object will be returned.
* If the storage ID is also zero, then all objects on all storage units will be returned.
*
* @param deviceName the name of the USB device
* @param storageId the ID of the storage unit to query, or zero for all
* @param objectHandle the handle of the parent object to query, or zero for the storage root
* @return the list of MtpObjectInfo
*/
public List<MtpObjectInfo> getObjectList(String deviceName, int storageId, int objectHandle) {
MtpDevice device = getDevice(deviceName);
if (device == null) {
return null;
}
if (objectHandle == 0) {
// all objects in root of storage
objectHandle = 0xFFFFFFFF;
}
int[] handles = device.getObjectHandles(storageId, 0, objectHandle);
if (handles == null) {
return null;
}
int length = handles.length;
ArrayList<MtpObjectInfo> objectList = new ArrayList<MtpObjectInfo>(length);
for (int i = 0; i < length; i++) {
MtpObjectInfo info = device.getObjectInfo(handles[i]);
if (info == null) {
Log.w(TAG, "getObjectInfo failed");
} else {
objectList.add(info);
}
}
return objectList;
}
/**
* Returns the data for an object as a byte array.
*
* @param deviceName the name of the USB device containing the object
* @param objectHandle handle of the object to read
* @param objectSize the size of the object (this should match
* {@link android.mtp.MtpObjectInfo#getCompressedSize}
* @return the object's data, or null if reading fails
*/
public byte[] getObject(String deviceName, int objectHandle, int objectSize) {
MtpDevice device = getDevice(deviceName);
if (device == null) {
return null;
}
return device.getObject(objectHandle, objectSize);
}
/**
* Returns the thumbnail data for an object as a byte array.
*
* @param deviceName the name of the USB device containing the object
* @param objectHandle handle of the object to read
* @return the object's thumbnail, or null if reading fails
*/
public byte[] getThumbnail(String deviceName, int objectHandle) {
MtpDevice device = getDevice(deviceName);
if (device == null) {
return null;
}
return device.getThumbnail(objectHandle);
}
/**
* Copies the data for an object to a file in external storage.
*
* @param deviceName the name of the USB device containing the object
* @param objectHandle handle of the object to read
* @param destPath path to destination for the file transfer.
* This path should be in the external storage as defined by
* {@link android.os.Environment#getExternalStorageDirectory}
* @return true if the file transfer succeeds
*/
public boolean importFile(String deviceName, int objectHandle, String destPath) {
MtpDevice device = getDevice(deviceName);
if (device == null) {
return false;
}
return device.importFile(objectHandle, destPath);
}
}
|
