1 /* 2 * Copyright (C) 2010 The Android Open Source Project 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 17 #define LOG_TAG "MtpDevice" 18 19 #include "MtpDebug.h" 20 #include "MtpDevice.h" 21 #include "MtpDeviceInfo.h" 22 #include "MtpObjectInfo.h" 23 #include "MtpProperty.h" 24 #include "MtpStorageInfo.h" 25 #include "MtpStringBuffer.h" 26 #include "MtpUtils.h" 27 28 #include <stdio.h> 29 #include <stdlib.h> 30 #include <sys/types.h> 31 #include <sys/ioctl.h> 32 #include <sys/stat.h> 33 #include <fcntl.h> 34 #include <errno.h> 35 #include <endian.h> 36 37 #include <usbhost/usbhost.h> 38 39 namespace android { 40 41 #if 0 42 static bool isMtpDevice(uint16_t vendor, uint16_t product) { 43 // Sandisk Sansa Fuze 44 if (vendor == 0x0781 && product == 0x74c2) 45 return true; 46 // Samsung YP-Z5 47 if (vendor == 0x04e8 && product == 0x503c) 48 return true; 49 return false; 50 } 51 #endif 52 53 MtpDevice* MtpDevice::open(const char* deviceName, int fd) { 54 struct usb_device *device = usb_device_new(deviceName, fd); 55 if (!device) { 56 ALOGE("usb_device_new failed for %s", deviceName); 57 return NULL; 58 } 59 60 struct usb_descriptor_header* desc; 61 struct usb_descriptor_iter iter; 62 63 usb_descriptor_iter_init(device, &iter); 64 65 while ((desc = usb_descriptor_iter_next(&iter)) != NULL) { 66 if (desc->bDescriptorType == USB_DT_INTERFACE) { 67 struct usb_interface_descriptor *interface = (struct usb_interface_descriptor *)desc; 68 69 if (interface->bInterfaceClass == USB_CLASS_STILL_IMAGE && 70 interface->bInterfaceSubClass == 1 && // Still Image Capture 71 interface->bInterfaceProtocol == 1) // Picture Transfer Protocol (PIMA 15470) 72 { 73 char* manufacturerName = usb_device_get_manufacturer_name(device); 74 char* productName = usb_device_get_product_name(device); 75 ALOGD("Found camera: \"%s\" \"%s\"\n", manufacturerName, productName); 76 free(manufacturerName); 77 free(productName); 78 } else if (interface->bInterfaceClass == 0xFF && 79 interface->bInterfaceSubClass == 0xFF && 80 interface->bInterfaceProtocol == 0) { 81 char* interfaceName = usb_device_get_string(device, interface->iInterface); 82 if (!interfaceName) { 83 continue; 84 } else if (strcmp(interfaceName, "MTP")) { 85 free(interfaceName); 86 continue; 87 } 88 free(interfaceName); 89 90 // Looks like an android style MTP device 91 char* manufacturerName = usb_device_get_manufacturer_name(device); 92 char* productName = usb_device_get_product_name(device); 93 ALOGD("Found MTP device: \"%s\" \"%s\"\n", manufacturerName, productName); 94 free(manufacturerName); 95 free(productName); 96 } 97 #if 0 98 else { 99 // look for special cased devices based on vendor/product ID 100 // we are doing this mainly for testing purposes 101 uint16_t vendor = usb_device_get_vendor_id(device); 102 uint16_t product = usb_device_get_product_id(device); 103 if (!isMtpDevice(vendor, product)) { 104 // not an MTP or PTP device 105 continue; 106 } 107 // request MTP OS string and descriptor 108 // some music players need to see this before entering MTP mode. 109 char buffer[256]; 110 memset(buffer, 0, sizeof(buffer)); 111 int ret = usb_device_control_transfer(device, 112 USB_DIR_IN|USB_RECIP_DEVICE|USB_TYPE_STANDARD, 113 USB_REQ_GET_DESCRIPTOR, (USB_DT_STRING << 8) | 0xEE, 114 0, buffer, sizeof(buffer), 0); 115 printf("usb_device_control_transfer returned %d errno: %d\n", ret, errno); 116 if (ret > 0) { 117 printf("got MTP string %s\n", buffer); 118 ret = usb_device_control_transfer(device, 119 USB_DIR_IN|USB_RECIP_DEVICE|USB_TYPE_VENDOR, 1, 120 0, 4, buffer, sizeof(buffer), 0); 121 printf("OS descriptor got %d\n", ret); 122 } else { 123 printf("no MTP string\n"); 124 } 125 } 126 #endif 127 // if we got here, then we have a likely MTP or PTP device 128 129 // interface should be followed by three endpoints 130 struct usb_endpoint_descriptor *ep; 131 struct usb_endpoint_descriptor *ep_in_desc = NULL; 132 struct usb_endpoint_descriptor *ep_out_desc = NULL; 133 struct usb_endpoint_descriptor *ep_intr_desc = NULL; 134 for (int i = 0; i < 3; i++) { 135 ep = (struct usb_endpoint_descriptor *)usb_descriptor_iter_next(&iter); 136 if (!ep || ep->bDescriptorType != USB_DT_ENDPOINT) { 137 ALOGE("endpoints not found\n"); 138 usb_device_close(device); 139 return NULL; 140 } 141 if (ep->bmAttributes == USB_ENDPOINT_XFER_BULK) { 142 if (ep->bEndpointAddress & USB_ENDPOINT_DIR_MASK) 143 ep_in_desc = ep; 144 else 145 ep_out_desc = ep; 146 } else if (ep->bmAttributes == USB_ENDPOINT_XFER_INT && 147 ep->bEndpointAddress & USB_ENDPOINT_DIR_MASK) { 148 ep_intr_desc = ep; 149 } 150 } 151 if (!ep_in_desc || !ep_out_desc || !ep_intr_desc) { 152 ALOGE("endpoints not found\n"); 153 usb_device_close(device); 154 return NULL; 155 } 156 157 if (usb_device_claim_interface(device, interface->bInterfaceNumber)) { 158 ALOGE("usb_device_claim_interface failed errno: %d\n", errno); 159 usb_device_close(device); 160 return NULL; 161 } 162 163 MtpDevice* mtpDevice = new MtpDevice(device, interface->bInterfaceNumber, 164 ep_in_desc, ep_out_desc, ep_intr_desc); 165 mtpDevice->initialize(); 166 return mtpDevice; 167 } 168 } 169 170 usb_device_close(device); 171 ALOGE("device not found"); 172 return NULL; 173 } 174 175 MtpDevice::MtpDevice(struct usb_device* device, int interface, 176 const struct usb_endpoint_descriptor *ep_in, 177 const struct usb_endpoint_descriptor *ep_out, 178 const struct usb_endpoint_descriptor *ep_intr) 179 : mDevice(device), 180 mInterface(interface), 181 mRequestIn1(NULL), 182 mRequestIn2(NULL), 183 mRequestOut(NULL), 184 mRequestIntr(NULL), 185 mDeviceInfo(NULL), 186 mSessionID(0), 187 mTransactionID(0), 188 mReceivedResponse(false) 189 { 190 mRequestIn1 = usb_request_new(device, ep_in); 191 mRequestIn2 = usb_request_new(device, ep_in); 192 mRequestOut = usb_request_new(device, ep_out); 193 mRequestIntr = usb_request_new(device, ep_intr); 194 } 195 196 MtpDevice::~MtpDevice() { 197 close(); 198 for (size_t i = 0; i < mDeviceProperties.size(); i++) 199 delete mDeviceProperties[i]; 200 usb_request_free(mRequestIn1); 201 usb_request_free(mRequestIn2); 202 usb_request_free(mRequestOut); 203 usb_request_free(mRequestIntr); 204 } 205 206 void MtpDevice::initialize() { 207 openSession(); 208 mDeviceInfo = getDeviceInfo(); 209 if (mDeviceInfo) { 210 if (mDeviceInfo->mDeviceProperties) { 211 int count = mDeviceInfo->mDeviceProperties->size(); 212 for (int i = 0; i < count; i++) { 213 MtpDeviceProperty propCode = (*mDeviceInfo->mDeviceProperties)[i]; 214 MtpProperty* property = getDevicePropDesc(propCode); 215 if (property) 216 mDeviceProperties.push(property); 217 } 218 } 219 } 220 } 221 222 void MtpDevice::close() { 223 if (mDevice) { 224 usb_device_release_interface(mDevice, mInterface); 225 usb_device_close(mDevice); 226 mDevice = NULL; 227 } 228 } 229 230 void MtpDevice::print() { 231 if (mDeviceInfo) { 232 mDeviceInfo->print(); 233 234 if (mDeviceInfo->mDeviceProperties) { 235 ALOGI("***** DEVICE PROPERTIES *****\n"); 236 int count = mDeviceInfo->mDeviceProperties->size(); 237 for (int i = 0; i < count; i++) { 238 MtpDeviceProperty propCode = (*mDeviceInfo->mDeviceProperties)[i]; 239 MtpProperty* property = getDevicePropDesc(propCode); 240 if (property) { 241 property->print(); 242 delete property; 243 } 244 } 245 } 246 } 247 248 if (mDeviceInfo->mPlaybackFormats) { 249 ALOGI("***** OBJECT PROPERTIES *****\n"); 250 int count = mDeviceInfo->mPlaybackFormats->size(); 251 for (int i = 0; i < count; i++) { 252 MtpObjectFormat format = (*mDeviceInfo->mPlaybackFormats)[i]; 253 ALOGI("*** FORMAT: %s\n", MtpDebug::getFormatCodeName(format)); 254 MtpObjectPropertyList* props = getObjectPropsSupported(format); 255 if (props) { 256 for (size_t j = 0; j < props->size(); j++) { 257 MtpObjectProperty prop = (*props)[j]; 258 MtpProperty* property = getObjectPropDesc(prop, format); 259 if (property) { 260 property->print(); 261 delete property; 262 } else { 263 ALOGE("could not fetch property: %s", 264 MtpDebug::getObjectPropCodeName(prop)); 265 } 266 } 267 } 268 } 269 } 270 } 271 272 const char* MtpDevice::getDeviceName() { 273 if (mDevice) 274 return usb_device_get_name(mDevice); 275 else 276 return "???"; 277 } 278 279 bool MtpDevice::openSession() { 280 Mutex::Autolock autoLock(mMutex); 281 282 mSessionID = 0; 283 mTransactionID = 0; 284 MtpSessionID newSession = 1; 285 mRequest.reset(); 286 mRequest.setParameter(1, newSession); 287 if (!sendRequest(MTP_OPERATION_OPEN_SESSION)) 288 return false; 289 MtpResponseCode ret = readResponse(); 290 if (ret == MTP_RESPONSE_SESSION_ALREADY_OPEN) 291 newSession = mResponse.getParameter(1); 292 else if (ret != MTP_RESPONSE_OK) 293 return false; 294 295 mSessionID = newSession; 296 mTransactionID = 1; 297 return true; 298 } 299 300 bool MtpDevice::closeSession() { 301 // FIXME 302 return true; 303 } 304 305 MtpDeviceInfo* MtpDevice::getDeviceInfo() { 306 Mutex::Autolock autoLock(mMutex); 307 308 mRequest.reset(); 309 if (!sendRequest(MTP_OPERATION_GET_DEVICE_INFO)) 310 return NULL; 311 if (!readData()) 312 return NULL; 313 MtpResponseCode ret = readResponse(); 314 if (ret == MTP_RESPONSE_OK) { 315 MtpDeviceInfo* info = new MtpDeviceInfo; 316 if (info->read(mData)) 317 return info; 318 else 319 delete info; 320 } 321 return NULL; 322 } 323 324 MtpStorageIDList* MtpDevice::getStorageIDs() { 325 Mutex::Autolock autoLock(mMutex); 326 327 mRequest.reset(); 328 if (!sendRequest(MTP_OPERATION_GET_STORAGE_IDS)) 329 return NULL; 330 if (!readData()) 331 return NULL; 332 MtpResponseCode ret = readResponse(); 333 if (ret == MTP_RESPONSE_OK) { 334 return mData.getAUInt32(); 335 } 336 return NULL; 337 } 338 339 MtpStorageInfo* MtpDevice::getStorageInfo(MtpStorageID storageID) { 340 Mutex::Autolock autoLock(mMutex); 341 342 mRequest.reset(); 343 mRequest.setParameter(1, storageID); 344 if (!sendRequest(MTP_OPERATION_GET_STORAGE_INFO)) 345 return NULL; 346 if (!readData()) 347 return NULL; 348 MtpResponseCode ret = readResponse(); 349 if (ret == MTP_RESPONSE_OK) { 350 MtpStorageInfo* info = new MtpStorageInfo(storageID); 351 if (info->read(mData)) 352 return info; 353 else 354 delete info; 355 } 356 return NULL; 357 } 358 359 MtpObjectHandleList* MtpDevice::getObjectHandles(MtpStorageID storageID, 360 MtpObjectFormat format, MtpObjectHandle parent) { 361 Mutex::Autolock autoLock(mMutex); 362 363 mRequest.reset(); 364 mRequest.setParameter(1, storageID); 365 mRequest.setParameter(2, format); 366 mRequest.setParameter(3, parent); 367 if (!sendRequest(MTP_OPERATION_GET_OBJECT_HANDLES)) 368 return NULL; 369 if (!readData()) 370 return NULL; 371 MtpResponseCode ret = readResponse(); 372 if (ret == MTP_RESPONSE_OK) { 373 return mData.getAUInt32(); 374 } 375 return NULL; 376 } 377 378 MtpObjectInfo* MtpDevice::getObjectInfo(MtpObjectHandle handle) { 379 Mutex::Autolock autoLock(mMutex); 380 381 // FIXME - we might want to add some caching here 382 383 mRequest.reset(); 384 mRequest.setParameter(1, handle); 385 if (!sendRequest(MTP_OPERATION_GET_OBJECT_INFO)) 386 return NULL; 387 if (!readData()) 388 return NULL; 389 MtpResponseCode ret = readResponse(); 390 if (ret == MTP_RESPONSE_OK) { 391 MtpObjectInfo* info = new MtpObjectInfo(handle); 392 if (info->read(mData)) 393 return info; 394 else 395 delete info; 396 } 397 return NULL; 398 } 399 400 void* MtpDevice::getThumbnail(MtpObjectHandle handle, int& outLength) { 401 Mutex::Autolock autoLock(mMutex); 402 403 mRequest.reset(); 404 mRequest.setParameter(1, handle); 405 if (sendRequest(MTP_OPERATION_GET_THUMB) && readData()) { 406 MtpResponseCode ret = readResponse(); 407 if (ret == MTP_RESPONSE_OK) { 408 return mData.getData(outLength); 409 } 410 } 411 outLength = 0; 412 return NULL; 413 } 414 415 MtpObjectHandle MtpDevice::sendObjectInfo(MtpObjectInfo* info) { 416 Mutex::Autolock autoLock(mMutex); 417 418 mRequest.reset(); 419 MtpObjectHandle parent = info->mParent; 420 if (parent == 0) 421 parent = MTP_PARENT_ROOT; 422 423 mRequest.setParameter(1, info->mStorageID); 424 mRequest.setParameter(2, info->mParent); 425 426 mData.putUInt32(info->mStorageID); 427 mData.putUInt16(info->mFormat); 428 mData.putUInt16(info->mProtectionStatus); 429 mData.putUInt32(info->mCompressedSize); 430 mData.putUInt16(info->mThumbFormat); 431 mData.putUInt32(info->mThumbCompressedSize); 432 mData.putUInt32(info->mThumbPixWidth); 433 mData.putUInt32(info->mThumbPixHeight); 434 mData.putUInt32(info->mImagePixWidth); 435 mData.putUInt32(info->mImagePixHeight); 436 mData.putUInt32(info->mImagePixDepth); 437 mData.putUInt32(info->mParent); 438 mData.putUInt16(info->mAssociationType); 439 mData.putUInt32(info->mAssociationDesc); 440 mData.putUInt32(info->mSequenceNumber); 441 mData.putString(info->mName); 442 443 char created[100], modified[100]; 444 formatDateTime(info->mDateCreated, created, sizeof(created)); 445 formatDateTime(info->mDateModified, modified, sizeof(modified)); 446 447 mData.putString(created); 448 mData.putString(modified); 449 if (info->mKeywords) 450 mData.putString(info->mKeywords); 451 else 452 mData.putEmptyString(); 453 454 if (sendRequest(MTP_OPERATION_SEND_OBJECT_INFO) && sendData()) { 455 MtpResponseCode ret = readResponse(); 456 if (ret == MTP_RESPONSE_OK) { 457 info->mStorageID = mResponse.getParameter(1); 458 info->mParent = mResponse.getParameter(2); 459 info->mHandle = mResponse.getParameter(3); 460 return info->mHandle; 461 } 462 } 463 return (MtpObjectHandle)-1; 464 } 465 466 bool MtpDevice::sendObject(MtpObjectInfo* info, int srcFD) { 467 Mutex::Autolock autoLock(mMutex); 468 469 int remaining = info->mCompressedSize; 470 mRequest.reset(); 471 mRequest.setParameter(1, info->mHandle); 472 if (sendRequest(MTP_OPERATION_SEND_OBJECT)) { 473 // send data header 474 writeDataHeader(MTP_OPERATION_SEND_OBJECT, remaining); 475 476 char buffer[65536]; 477 while (remaining > 0) { 478 int count = read(srcFD, buffer, sizeof(buffer)); 479 if (count > 0) { 480 int written = mData.write(mRequestOut, buffer, count); 481 // FIXME check error 482 remaining -= count; 483 } else { 484 break; 485 } 486 } 487 } 488 MtpResponseCode ret = readResponse(); 489 return (remaining == 0 && ret == MTP_RESPONSE_OK); 490 } 491 492 bool MtpDevice::deleteObject(MtpObjectHandle handle) { 493 Mutex::Autolock autoLock(mMutex); 494 495 mRequest.reset(); 496 mRequest.setParameter(1, handle); 497 if (sendRequest(MTP_OPERATION_DELETE_OBJECT)) { 498 MtpResponseCode ret = readResponse(); 499 if (ret == MTP_RESPONSE_OK) 500 return true; 501 } 502 return false; 503 } 504 505 MtpObjectHandle MtpDevice::getParent(MtpObjectHandle handle) { 506 MtpObjectInfo* info = getObjectInfo(handle); 507 if (info) { 508 MtpObjectHandle parent = info->mParent; 509 delete info; 510 return parent; 511 } else { 512 return -1; 513 } 514 } 515 516 MtpObjectHandle MtpDevice::getStorageID(MtpObjectHandle handle) { 517 MtpObjectInfo* info = getObjectInfo(handle); 518 if (info) { 519 MtpObjectHandle storageId = info->mStorageID; 520 delete info; 521 return storageId; 522 } else { 523 return -1; 524 } 525 } 526 527 MtpObjectPropertyList* MtpDevice::getObjectPropsSupported(MtpObjectFormat format) { 528 Mutex::Autolock autoLock(mMutex); 529 530 mRequest.reset(); 531 mRequest.setParameter(1, format); 532 if (!sendRequest(MTP_OPERATION_GET_OBJECT_PROPS_SUPPORTED)) 533 return NULL; 534 if (!readData()) 535 return NULL; 536 MtpResponseCode ret = readResponse(); 537 if (ret == MTP_RESPONSE_OK) { 538 return mData.getAUInt16(); 539 } 540 return NULL; 541 542 } 543 544 MtpProperty* MtpDevice::getDevicePropDesc(MtpDeviceProperty code) { 545 Mutex::Autolock autoLock(mMutex); 546 547 mRequest.reset(); 548 mRequest.setParameter(1, code); 549 if (!sendRequest(MTP_OPERATION_GET_DEVICE_PROP_DESC)) 550 return NULL; 551 if (!readData()) 552 return NULL; 553 MtpResponseCode ret = readResponse(); 554 if (ret == MTP_RESPONSE_OK) { 555 MtpProperty* property = new MtpProperty; 556 if (property->read(mData)) 557 return property; 558 else 559 delete property; 560 } 561 return NULL; 562 } 563 564 MtpProperty* MtpDevice::getObjectPropDesc(MtpObjectProperty code, MtpObjectFormat format) { 565 Mutex::Autolock autoLock(mMutex); 566 567 mRequest.reset(); 568 mRequest.setParameter(1, code); 569 mRequest.setParameter(2, format); 570 if (!sendRequest(MTP_OPERATION_GET_OBJECT_PROP_DESC)) 571 return NULL; 572 if (!readData()) 573 return NULL; 574 MtpResponseCode ret = readResponse(); 575 if (ret == MTP_RESPONSE_OK) { 576 MtpProperty* property = new MtpProperty; 577 if (property->read(mData)) 578 return property; 579 else 580 delete property; 581 } 582 return NULL; 583 } 584 585 bool MtpDevice::readObject(MtpObjectHandle handle, 586 bool (* callback)(void* data, int offset, int length, void* clientData), 587 size_t objectSize, void* clientData) { 588 Mutex::Autolock autoLock(mMutex); 589 bool result = false; 590 591 mRequest.reset(); 592 mRequest.setParameter(1, handle); 593 if (sendRequest(MTP_OPERATION_GET_OBJECT) 594 && mData.readDataHeader(mRequestIn1)) { 595 uint32_t length = mData.getContainerLength(); 596 if (length - MTP_CONTAINER_HEADER_SIZE != objectSize) { 597 ALOGE("readObject error objectSize: %d, length: %d", 598 objectSize, length); 599 goto fail; 600 } 601 length -= MTP_CONTAINER_HEADER_SIZE; 602 uint32_t remaining = length; 603 int offset = 0; 604 605 int initialDataLength = 0; 606 void* initialData = mData.getData(initialDataLength); 607 if (initialData) { 608 if (initialDataLength > 0) { 609 if (!callback(initialData, 0, initialDataLength, clientData)) 610 goto fail; 611 remaining -= initialDataLength; 612 offset += initialDataLength; 613 } 614 free(initialData); 615 } 616 617 // USB reads greater than 16K don't work 618 char buffer1[16384], buffer2[16384]; 619 mRequestIn1->buffer = buffer1; 620 mRequestIn2->buffer = buffer2; 621 struct usb_request* req = mRequestIn1; 622 void* writeBuffer = NULL; 623 int writeLength = 0; 624 625 while (remaining > 0 || writeBuffer) { 626 if (remaining > 0) { 627 // queue up a read request 628 req->buffer_length = (remaining > sizeof(buffer1) ? sizeof(buffer1) : remaining); 629 if (mData.readDataAsync(req)) { 630 ALOGE("readDataAsync failed"); 631 goto fail; 632 } 633 } else { 634 req = NULL; 635 } 636 637 if (writeBuffer) { 638 // write previous buffer 639 if (!callback(writeBuffer, offset, writeLength, clientData)) { 640 ALOGE("write failed"); 641 // wait for pending read before failing 642 if (req) 643 mData.readDataWait(mDevice); 644 goto fail; 645 } 646 offset += writeLength; 647 writeBuffer = NULL; 648 } 649 650 // wait for read to complete 651 if (req) { 652 int read = mData.readDataWait(mDevice); 653 if (read < 0) 654 goto fail; 655 656 if (read > 0) { 657 writeBuffer = req->buffer; 658 writeLength = read; 659 remaining -= read; 660 req = (req == mRequestIn1 ? mRequestIn2 : mRequestIn1); 661 } else { 662 writeBuffer = NULL; 663 } 664 } 665 } 666 667 MtpResponseCode response = readResponse(); 668 if (response == MTP_RESPONSE_OK) 669 result = true; 670 } 671 672 fail: 673 return result; 674 } 675 676 677 // reads the object's data and writes it to the specified file path 678 bool MtpDevice::readObject(MtpObjectHandle handle, const char* destPath, int group, int perm) { 679 ALOGD("readObject: %s", destPath); 680 int fd = ::open(destPath, O_RDWR | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR); 681 if (fd < 0) { 682 ALOGE("open failed for %s", destPath); 683 return false; 684 } 685 686 fchown(fd, getuid(), group); 687 // set permissions 688 int mask = umask(0); 689 fchmod(fd, perm); 690 umask(mask); 691 692 Mutex::Autolock autoLock(mMutex); 693 bool result = false; 694 695 mRequest.reset(); 696 mRequest.setParameter(1, handle); 697 if (sendRequest(MTP_OPERATION_GET_OBJECT) 698 && mData.readDataHeader(mRequestIn1)) { 699 uint32_t length = mData.getContainerLength(); 700 if (length < MTP_CONTAINER_HEADER_SIZE) 701 goto fail; 702 length -= MTP_CONTAINER_HEADER_SIZE; 703 uint32_t remaining = length; 704 705 int initialDataLength = 0; 706 void* initialData = mData.getData(initialDataLength); 707 if (initialData) { 708 if (initialDataLength > 0) { 709 if (write(fd, initialData, initialDataLength) != initialDataLength) { 710 free(initialData); 711 goto fail; 712 } 713 remaining -= initialDataLength; 714 } 715 free(initialData); 716 } 717 718 // USB reads greater than 16K don't work 719 char buffer1[16384], buffer2[16384]; 720 mRequestIn1->buffer = buffer1; 721 mRequestIn2->buffer = buffer2; 722 struct usb_request* req = mRequestIn1; 723 void* writeBuffer = NULL; 724 int writeLength = 0; 725 726 while (remaining > 0 || writeBuffer) { 727 if (remaining > 0) { 728 // queue up a read request 729 req->buffer_length = (remaining > sizeof(buffer1) ? sizeof(buffer1) : remaining); 730 if (mData.readDataAsync(req)) { 731 ALOGE("readDataAsync failed"); 732 goto fail; 733 } 734 } else { 735 req = NULL; 736 } 737 738 if (writeBuffer) { 739 // write previous buffer 740 if (write(fd, writeBuffer, writeLength) != writeLength) { 741 ALOGE("write failed"); 742 // wait for pending read before failing 743 if (req) 744 mData.readDataWait(mDevice); 745 goto fail; 746 } 747 writeBuffer = NULL; 748 } 749 750 // wait for read to complete 751 if (req) { 752 int read = mData.readDataWait(mDevice); 753 if (read < 0) 754 goto fail; 755 756 if (read > 0) { 757 writeBuffer = req->buffer; 758 writeLength = read; 759 remaining -= read; 760 req = (req == mRequestIn1 ? mRequestIn2 : mRequestIn1); 761 } else { 762 writeBuffer = NULL; 763 } 764 } 765 } 766 767 MtpResponseCode response = readResponse(); 768 if (response == MTP_RESPONSE_OK) 769 result = true; 770 } 771 772 fail: 773 ::close(fd); 774 return result; 775 } 776 777 bool MtpDevice::sendRequest(MtpOperationCode operation) { 778 ALOGV("sendRequest: %s\n", MtpDebug::getOperationCodeName(operation)); 779 mReceivedResponse = false; 780 mRequest.setOperationCode(operation); 781 if (mTransactionID > 0) 782 mRequest.setTransactionID(mTransactionID++); 783 int ret = mRequest.write(mRequestOut); 784 mRequest.dump(); 785 return (ret > 0); 786 } 787 788 bool MtpDevice::sendData() { 789 ALOGV("sendData\n"); 790 mData.setOperationCode(mRequest.getOperationCode()); 791 mData.setTransactionID(mRequest.getTransactionID()); 792 int ret = mData.write(mRequestOut); 793 mData.dump(); 794 return (ret > 0); 795 } 796 797 bool MtpDevice::readData() { 798 mData.reset(); 799 int ret = mData.read(mRequestIn1); 800 ALOGV("readData returned %d\n", ret); 801 if (ret >= MTP_CONTAINER_HEADER_SIZE) { 802 if (mData.getContainerType() == MTP_CONTAINER_TYPE_RESPONSE) { 803 ALOGD("got response packet instead of data packet"); 804 // we got a response packet rather than data 805 // copy it to mResponse 806 mResponse.copyFrom(mData); 807 mReceivedResponse = true; 808 return false; 809 } 810 mData.dump(); 811 return true; 812 } 813 else { 814 ALOGV("readResponse failed\n"); 815 return false; 816 } 817 } 818 819 bool MtpDevice::writeDataHeader(MtpOperationCode operation, int dataLength) { 820 mData.setOperationCode(operation); 821 mData.setTransactionID(mRequest.getTransactionID()); 822 return (!mData.writeDataHeader(mRequestOut, dataLength)); 823 } 824 825 MtpResponseCode MtpDevice::readResponse() { 826 ALOGV("readResponse\n"); 827 if (mReceivedResponse) { 828 mReceivedResponse = false; 829 return mResponse.getResponseCode(); 830 } 831 int ret = mResponse.read(mRequestIn1); 832 // handle zero length packets, which might occur if the data transfer 833 // ends on a packet boundary 834 if (ret == 0) 835 ret = mResponse.read(mRequestIn1); 836 if (ret >= MTP_CONTAINER_HEADER_SIZE) { 837 mResponse.dump(); 838 return mResponse.getResponseCode(); 839 } else { 840 ALOGD("readResponse failed\n"); 841 return -1; 842 } 843 } 844 845 } // namespace android 846
