diff options
author | bigbiff bigbiff <bigbiff@teamw.in> | 2018-12-19 00:39:53 +0100 |
---|---|---|
committer | Ethan Yonker <dees_troy@teamw.in> | 2019-03-20 20:28:21 +0100 |
commit | af32bb9c4f4f06e92de3435ed2db3153c0701094 (patch) | |
tree | 622948fb3167dc17bb436c948d61df581d2e75f7 /mtp/ffs/MtpDevice.h | |
parent | Adding Edl button in reboot menu (diff) | |
download | android_bootable_recovery-af32bb9c4f4f06e92de3435ed2db3153c0701094.tar android_bootable_recovery-af32bb9c4f4f06e92de3435ed2db3153c0701094.tar.gz android_bootable_recovery-af32bb9c4f4f06e92de3435ed2db3153c0701094.tar.bz2 android_bootable_recovery-af32bb9c4f4f06e92de3435ed2db3153c0701094.tar.lz android_bootable_recovery-af32bb9c4f4f06e92de3435ed2db3153c0701094.tar.xz android_bootable_recovery-af32bb9c4f4f06e92de3435ed2db3153c0701094.tar.zst android_bootable_recovery-af32bb9c4f4f06e92de3435ed2db3153c0701094.zip |
Diffstat (limited to '')
-rw-r--r-- | mtp/ffs/MtpDevice.h | 167 |
1 files changed, 167 insertions, 0 deletions
diff --git a/mtp/ffs/MtpDevice.h b/mtp/ffs/MtpDevice.h new file mode 100644 index 000000000..da00a81a3 --- /dev/null +++ b/mtp/ffs/MtpDevice.h @@ -0,0 +1,167 @@ +/* + * 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. + */ + +#ifndef _MTP_DEVICE_H +#define _MTP_DEVICE_H + +#include "MtpEventPacket.h" +#include "MtpDataPacket.h" +#include "MtpRequestPacket.h" +#include "MtpResponsePacket.h" +#include "MtpTypes.h" + +#include <mutex> + +struct usb_device; +struct usb_request; +struct usb_endpoint_descriptor; + +class MtpDeviceInfo; +class MtpEventPacket; +class MtpObjectInfo; +class MtpStorageInfo; + +class MtpDevice { +private: + struct usb_device* mDevice; + int mInterface; + struct usb_request* mRequestIn1; + struct usb_request* mRequestIn2; + struct usb_request* mRequestOut; + struct usb_request* mRequestIntr; + MtpDeviceInfo* mDeviceInfo; + MtpPropertyList mDeviceProperties; + + // current session ID + MtpSessionID mSessionID; + // current transaction ID + MtpTransactionID mTransactionID; + + MtpRequestPacket mRequest; + MtpDataPacket mData; + MtpResponsePacket mResponse; + MtpEventPacket mEventPacket; + + // set to true if we received a response packet instead of a data packet + bool mReceivedResponse; + bool mProcessingEvent; + int mCurrentEventHandle; + + // to check if a sendObject request follows the last sendObjectInfo request. + MtpTransactionID mLastSendObjectInfoTransactionID; + MtpObjectHandle mLastSendObjectInfoObjectHandle; + + // to ensure only one MTP transaction at a time + std::mutex mMutex; + std::mutex mEventMutex; + std::mutex mEventMutexForInterrupt; + + // Remember the device's packet division mode. + UrbPacketDivisionMode mPacketDivisionMode; + +public: + typedef bool (*ReadObjectCallback) + (void* data, uint32_t offset, uint32_t length, void* clientData); + + MtpDevice(struct usb_device* device, + int interface, + const struct usb_endpoint_descriptor *ep_in, + const struct usb_endpoint_descriptor *ep_out, + const struct usb_endpoint_descriptor *ep_intr); + + static MtpDevice* open(const char* deviceName, int fd); + + virtual ~MtpDevice(); + + void initialize(); + void close(); + void print(); + const char* getDeviceName(); + + bool openSession(); + bool closeSession(); + + MtpDeviceInfo* getDeviceInfo(); + MtpStorageIDList* getStorageIDs(); + MtpStorageInfo* getStorageInfo(MtpStorageID storageID); + MtpObjectHandleList* getObjectHandles(MtpStorageID storageID, MtpObjectFormat format, + MtpObjectHandle parent); + MtpObjectInfo* getObjectInfo(MtpObjectHandle handle); + void* getThumbnail(MtpObjectHandle handle, int& outLength); + MtpObjectHandle sendObjectInfo(MtpObjectInfo* info); + bool sendObject(MtpObjectHandle handle, int size, int srcFD); + bool deleteObject(MtpObjectHandle handle); + MtpObjectHandle getParent(MtpObjectHandle handle); + MtpStorageID getStorageID(MtpObjectHandle handle); + + MtpObjectPropertyList* getObjectPropsSupported(MtpObjectFormat format); + + MtpProperty* getDevicePropDesc(MtpDeviceProperty code); + MtpProperty* getObjectPropDesc(MtpObjectProperty code, MtpObjectFormat format); + + // Reads value of |property| for |handle|. Returns true on success. + bool getObjectPropValue(MtpObjectHandle handle, MtpProperty* property); + + bool readObject(MtpObjectHandle handle, ReadObjectCallback callback, + uint32_t objectSize, void* clientData); + bool readObject(MtpObjectHandle handle, const char* destPath, int group, + int perm); + bool readObject(MtpObjectHandle handle, int fd); + bool readPartialObject(MtpObjectHandle handle, + uint32_t offset, + uint32_t size, + uint32_t *writtenSize, + ReadObjectCallback callback, + void* clientData); + bool readPartialObject64(MtpObjectHandle handle, + uint64_t offset, + uint32_t size, + uint32_t *writtenSize, + ReadObjectCallback callback, + void* clientData); + // Starts a request to read MTP event from MTP device. It returns a request handle that + // can be used for blocking read or cancel. If other thread has already been processing an + // event returns -1. + int submitEventRequest(); + // Waits for MTP event from the device and returns MTP event code. It blocks the current thread + // until it receives an event from the device. |handle| should be a request handle returned + // by |submitEventRequest|. The function writes event parameters to |parameters|. Returns 0 for + // cancellations. Returns -1 for errors. + int reapEventRequest(int handle, uint32_t (*parameters)[3]); + // Cancels an event request. |handle| should be request handle returned by + // |submitEventRequest|. If there is a thread blocked by |reapEventRequest| with the same + // |handle|, the thread will resume. + void discardEventRequest(int handle); + +private: + // If |objectSize| is not NULL, it checks object size before reading data bytes. + bool readObjectInternal(MtpObjectHandle handle, + ReadObjectCallback callback, + const uint32_t* objectSize, + void* clientData); + // If |objectSize| is not NULL, it checks object size before reading data bytes. + bool readData(ReadObjectCallback callback, + const uint32_t* objectSize, + uint32_t* writtenData, + void* clientData); + bool sendRequest(MtpOperationCode operation); + bool sendData(); + bool readData(); + bool writeDataHeader(MtpOperationCode operation, int dataLength); + MtpResponseCode readResponse(); +}; + +#endif // _MTP_DEVICE_H |