OLD | NEW |
---|---|
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "chromeos/dbus/media_transfer_protocol_daemon_client.h" | 5 #include "chromeos/dbus/media_transfer_protocol_daemon_client.h" |
6 | 6 |
7 #include <map> | |
8 | |
9 #include "base/bind.h" | 7 #include "base/bind.h" |
10 #include "base/stl_util.h" | |
11 #include "base/stringprintf.h" | |
12 #include "dbus/bus.h" | 8 #include "dbus/bus.h" |
13 #include "dbus/message.h" | 9 #include "dbus/message.h" |
14 #include "dbus/object_path.h" | 10 #include "dbus/object_path.h" |
15 #include "dbus/object_proxy.h" | 11 #include "dbus/object_proxy.h" |
12 #include "chromeos/dbus/mtp_storage_info.pb.h" | |
16 #include "third_party/cros_system_api/dbus/service_constants.h" | 13 #include "third_party/cros_system_api/dbus/service_constants.h" |
17 | 14 |
18 namespace chromeos { | 15 namespace chromeos { |
19 | 16 |
20 namespace { | 17 namespace { |
21 | 18 |
22 // Pops a string value when |reader| is not NULL. | |
23 // Returns true when a value is popped, false otherwise. | |
24 bool MaybePopString(dbus::MessageReader* reader, std::string* value) { | |
25 if (!reader) | |
26 return false; | |
27 return reader->PopString(value); | |
28 } | |
29 | |
30 // Pops a uint16 value when |reader| is not NULL. | |
31 // Returns true when a value is popped, false otherwise. | |
32 bool MaybePopUint16(dbus::MessageReader* reader, uint16* value) { | |
33 if (!reader) | |
34 return false; | |
35 return reader->PopUint16(value); | |
36 } | |
37 | |
38 // Pops a uint32 value when |reader| is not NULL. | |
39 // Returns true when a value is popped, false otherwise. | |
40 bool MaybePopUint32(dbus::MessageReader* reader, uint32* value) { | |
41 if (!reader) | |
42 return false; | |
43 return reader->PopUint32(value); | |
44 } | |
45 | |
46 // Pops a uint64 value when |reader| is not NULL. | |
47 // Returns true when a value is popped, false otherwise. | |
48 bool MaybePopUint64(dbus::MessageReader* reader, uint64* value) { | |
49 if (!reader) | |
50 return false; | |
51 return reader->PopUint64(value); | |
52 } | |
53 | |
54 // Pops a int64 value when |reader| is not NULL. | |
55 // Returns true when a value is popped, false otherwise. | |
56 bool MaybePopInt64(dbus::MessageReader* reader, int64* value) { | |
57 if (!reader) | |
58 return false; | |
59 return reader->PopInt64(value); | |
60 } | |
61 | |
62 // The MediaTransferProtocolDaemonClient implementation. | 19 // The MediaTransferProtocolDaemonClient implementation. |
63 class MediaTransferProtocolDaemonClientImpl | 20 class MediaTransferProtocolDaemonClientImpl |
64 : public MediaTransferProtocolDaemonClient { | 21 : public MediaTransferProtocolDaemonClient { |
65 public: | 22 public: |
66 explicit MediaTransferProtocolDaemonClientImpl(dbus::Bus* bus) | 23 explicit MediaTransferProtocolDaemonClientImpl(dbus::Bus* bus) |
67 : proxy_(bus->GetObjectProxy( | 24 : proxy_(bus->GetObjectProxy( |
68 mtpd::kMtpdServiceName, | 25 mtpd::kMtpdServiceName, |
69 dbus::ObjectPath(mtpd::kMtpdServicePath))), | 26 dbus::ObjectPath(mtpd::kMtpdServicePath))), |
70 weak_ptr_factory_(this) { | 27 weak_ptr_factory_(this) { |
71 } | 28 } |
(...skipping 217 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
289 // Handles the result of GetStorageInfo and calls |callback| or | 246 // Handles the result of GetStorageInfo and calls |callback| or |
290 // |error_callback|. | 247 // |error_callback|. |
291 void OnGetStorageInfo(const std::string& storage_name, | 248 void OnGetStorageInfo(const std::string& storage_name, |
292 const GetStorageInfoCallback& callback, | 249 const GetStorageInfoCallback& callback, |
293 const ErrorCallback& error_callback, | 250 const ErrorCallback& error_callback, |
294 dbus::Response* response) { | 251 dbus::Response* response) { |
295 if (!response) { | 252 if (!response) { |
296 error_callback.Run(); | 253 error_callback.Run(); |
297 return; | 254 return; |
298 } | 255 } |
299 StorageInfo storage_info(storage_name, response); | 256 |
300 callback.Run(storage_info); | 257 dbus::MessageReader reader(response); |
258 MtpStorageInfo protobuf; | |
259 reader.PopArrayOfBytesAsProto(&protobuf); | |
260 callback.Run(StorageInfo(storage_name, protobuf)); | |
301 } | 261 } |
302 | 262 |
303 // Handles the result of OpenStorage and calls |callback| or |error_callback|. | 263 // Handles the result of OpenStorage and calls |callback| or |error_callback|. |
304 void OnOpenStorage(const OpenStorageCallback& callback, | 264 void OnOpenStorage(const OpenStorageCallback& callback, |
305 const ErrorCallback& error_callback, | 265 const ErrorCallback& error_callback, |
306 dbus::Response* response) { | 266 dbus::Response* response) { |
307 if (!response) { | 267 if (!response) { |
308 error_callback.Run(); | 268 error_callback.Run(); |
309 return; | 269 return; |
310 } | 270 } |
(...skipping 23 matching lines...) Expand all Loading... | |
334 // |error_callback|. | 294 // |error_callback|. |
335 void OnReadDirectory(const ReadDirectoryCallback& callback, | 295 void OnReadDirectory(const ReadDirectoryCallback& callback, |
336 const ErrorCallback& error_callback, | 296 const ErrorCallback& error_callback, |
337 dbus::Response* response) { | 297 dbus::Response* response) { |
338 if (!response) { | 298 if (!response) { |
339 error_callback.Run(); | 299 error_callback.Run(); |
340 return; | 300 return; |
341 } | 301 } |
342 | 302 |
343 std::vector<FileEntry> file_entries; | 303 std::vector<FileEntry> file_entries; |
344 dbus::MessageReader response_reader(response); | 304 dbus::MessageReader reader(response); |
345 dbus::MessageReader array_reader(response); | 305 MtpFileEntries entries_protobuf; |
346 if (!response_reader.PopArray(&array_reader)) { | 306 reader.PopArrayOfBytesAsProto(&entries_protobuf); |
347 LOG(ERROR) << "Invalid response: " << response->ToString(); | 307 for (int i = 0; i < entries_protobuf.file_entries_size(); ++i) |
348 error_callback.Run(); | 308 file_entries.push_back(FileEntry(entries_protobuf.file_entries(i))); |
349 return; | |
350 } | |
351 while (array_reader.HasMoreData()) { | |
352 FileEntry entry(response); | |
353 file_entries.push_back(entry); | |
354 } | |
355 callback.Run(file_entries); | 309 callback.Run(file_entries); |
356 } | 310 } |
357 | 311 |
358 // Handles the result of ReadFileByPath/Id and calls |callback| or | 312 // Handles the result of ReadFileByPath/Id and calls |callback| or |
359 // |error_callback|. | 313 // |error_callback|. |
360 void OnReadFile(const ReadFileCallback& callback, | 314 void OnReadFile(const ReadFileCallback& callback, |
361 const ErrorCallback& error_callback, | 315 const ErrorCallback& error_callback, |
362 dbus::Response* response) { | 316 dbus::Response* response) { |
363 if (!response) { | 317 if (!response) { |
364 error_callback.Run(); | 318 error_callback.Run(); |
(...skipping 14 matching lines...) Expand all Loading... | |
379 // Handles the result of GetFileInfoByPath/Id and calls |callback| or | 333 // Handles the result of GetFileInfoByPath/Id and calls |callback| or |
380 // |error_callback|. | 334 // |error_callback|. |
381 void OnGetFileInfo(const GetFileInfoCallback& callback, | 335 void OnGetFileInfo(const GetFileInfoCallback& callback, |
382 const ErrorCallback& error_callback, | 336 const ErrorCallback& error_callback, |
383 dbus::Response* response) { | 337 dbus::Response* response) { |
384 if (!response) { | 338 if (!response) { |
385 error_callback.Run(); | 339 error_callback.Run(); |
386 return; | 340 return; |
387 } | 341 } |
388 | 342 |
389 FileEntry file_entry(response); | 343 dbus::MessageReader reader(response); |
390 callback.Run(file_entry); | 344 MtpFileEntry protobuf; |
345 reader.PopArrayOfBytesAsProto(&protobuf); | |
346 callback.Run(FileEntry(protobuf)); | |
391 } | 347 } |
392 | 348 |
393 // Handles MTPStorageAttached/Dettached signals and calls |handler|. | 349 // Handles MTPStorageAttached/Dettached signals and calls |handler|. |
394 void OnMTPStorageSignal(MTPStorageEventHandler handler, | 350 void OnMTPStorageSignal(MTPStorageEventHandler handler, |
395 bool is_attach, | 351 bool is_attach, |
396 dbus::Signal* signal) { | 352 dbus::Signal* signal) { |
397 dbus::MessageReader reader(signal); | 353 dbus::MessageReader reader(signal); |
398 std::string storage_name; | 354 std::string storage_name; |
399 if (!reader.PopString(&storage_name)) { | 355 if (!reader.PopString(&storage_name)) { |
400 LOG(ERROR) << "Invalid signal: " << signal->ToString(); | 356 LOG(ERROR) << "Invalid signal: " << signal->ToString(); |
(...skipping 84 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
485 device_flags_(0), | 441 device_flags_(0), |
486 storage_type_(0), | 442 storage_type_(0), |
487 filesystem_type_(0), | 443 filesystem_type_(0), |
488 access_capability_(0), | 444 access_capability_(0), |
489 max_capacity_(0), | 445 max_capacity_(0), |
490 free_space_in_bytes_(0), | 446 free_space_in_bytes_(0), |
491 free_space_in_objects_(0) { | 447 free_space_in_objects_(0) { |
492 } | 448 } |
493 | 449 |
494 StorageInfo::StorageInfo(const std::string& storage_name, | 450 StorageInfo::StorageInfo(const std::string& storage_name, |
495 dbus::Response* response) | 451 const MtpStorageInfo& storage_info) |
496 : vendor_id_(0), | 452 : vendor_(storage_info.vendor()), |
497 product_id_(0), | 453 vendor_id_(storage_info.vendor_id()), |
498 device_flags_(0), | 454 product_(storage_info.product()), |
455 product_id_(storage_info.product_id()), | |
456 device_flags_(storage_info.device_flags()), | |
499 storage_name_(storage_name), | 457 storage_name_(storage_name), |
500 storage_type_(0), | 458 storage_type_(storage_info.storage_type()), |
501 filesystem_type_(0), | 459 filesystem_type_(storage_info.filesystem_type()), |
502 access_capability_(0), | 460 access_capability_(storage_info.access_capability()), |
503 max_capacity_(0), | 461 max_capacity_(storage_info.max_capacity()), |
504 free_space_in_bytes_(0), | 462 free_space_in_bytes_(storage_info.free_space_in_bytes()), |
505 free_space_in_objects_(0) { | 463 free_space_in_objects_(storage_info.free_space_in_objects()), |
506 InitializeFromResponse(response); | 464 storage_description_(storage_info.storage_description()), |
465 volume_identifier_(storage_info.volume_identifier()) { | |
satorux1
2012/09/01 01:03:50
do you need to copy the proto to the class? Wouldn
Lei Zhang
2012/09/04 20:09:38
Ya, we can. I just need to add the "storage name"
| |
507 } | 466 } |
508 | 467 |
509 StorageInfo::~StorageInfo() { | 468 StorageInfo::~StorageInfo() { |
510 } | 469 } |
511 | 470 |
512 // Initializes |this| from |response| given by the mtpd service. | |
513 void StorageInfo::InitializeFromResponse(dbus::Response* response) { | |
514 dbus::MessageReader response_reader(response); | |
515 dbus::MessageReader array_reader(response); | |
516 if (!response_reader.PopArray(&array_reader)) { | |
517 LOG(ERROR) << "Invalid response: " << response->ToString(); | |
518 return; | |
519 } | |
520 // TODO(thestig): Rework this code using Protocol Buffers. crosbug.com/22626 | |
521 typedef std::map<std::string, dbus::MessageReader*> PropertiesMap; | |
522 PropertiesMap properties; | |
523 STLValueDeleter<PropertiesMap> properties_value_deleter(&properties); | |
524 while (array_reader.HasMoreData()) { | |
525 dbus::MessageReader* value_reader = new dbus::MessageReader(response); | |
526 dbus::MessageReader dict_entry_reader(response); | |
527 std::string key; | |
528 if (!array_reader.PopDictEntry(&dict_entry_reader) || | |
529 !dict_entry_reader.PopString(&key) || | |
530 !dict_entry_reader.PopVariant(value_reader)) { | |
531 LOG(ERROR) << "Invalid response: " << response->ToString(); | |
532 return; | |
533 } | |
534 properties[key] = value_reader; | |
535 } | |
536 // TODO(thestig) Add enums for fields below as appropriate. | |
537 MaybePopString(properties[mtpd::kVendor], &vendor_); | |
538 MaybePopString(properties[mtpd::kProduct], &product_); | |
539 MaybePopString(properties[mtpd::kStorageDescription], &storage_description_); | |
540 MaybePopString(properties[mtpd::kVolumeIdentifier], &volume_identifier_); | |
541 MaybePopUint16(properties[mtpd::kVendorId], &vendor_id_); | |
542 MaybePopUint16(properties[mtpd::kProductId], &product_id_); | |
543 MaybePopUint16(properties[mtpd::kStorageType], &storage_type_); | |
544 MaybePopUint16(properties[mtpd::kFilesystemType], &filesystem_type_); | |
545 MaybePopUint16(properties[mtpd::kAccessCapability], &access_capability_); | |
546 MaybePopUint32(properties[mtpd::kDeviceFlags], &device_flags_); | |
547 MaybePopUint64(properties[mtpd::kMaxCapacity], &max_capacity_); | |
548 MaybePopUint64(properties[mtpd::kFreeSpaceInBytes], &free_space_in_bytes_); | |
549 MaybePopUint64(properties[mtpd::kFreeSpaceInObjects], | |
550 &free_space_in_objects_); | |
551 } | |
552 | |
553 //////////////////////////////////////////////////////////////////////////////// | 471 //////////////////////////////////////////////////////////////////////////////// |
554 // FileEntry | 472 // FileEntry |
555 | 473 |
556 FileEntry::FileEntry() | 474 FileEntry::FileEntry() |
557 : item_id_(0), | 475 : item_id_(0), |
558 parent_id_(0), | 476 parent_id_(0), |
559 file_size_(0), | 477 file_size_(0), |
560 file_type_(FILE_TYPE_UNKNOWN) { | 478 file_type_(MtpFileEntry_FileType_FILE_TYPE_UNKNOWN) { |
561 } | 479 } |
562 | 480 |
563 FileEntry::FileEntry(dbus::Response* response) | 481 FileEntry::FileEntry(const MtpFileEntry& entry) |
564 : item_id_(0), | 482 : item_id_(entry.item_id()), |
565 parent_id_(0), | 483 parent_id_(entry.parent_id()), |
566 file_size_(0), | 484 file_name_(entry.file_name()), |
567 file_type_(FILE_TYPE_UNKNOWN) { | 485 file_size_(entry.file_size()), |
568 InitializeFromResponse(response); | 486 modification_time_(base::Time::FromTimeT(entry.modification_time())), |
487 file_type_(entry.file_type()) { | |
satorux1
2012/09/01 01:03:50
ditto. Do you need FileEntry class? Can you use Mt
Lei Zhang
2012/09/04 20:09:38
Done.
| |
569 } | 488 } |
570 | 489 |
571 FileEntry::~FileEntry() { | 490 FileEntry::~FileEntry() { |
572 } | 491 } |
573 | 492 |
574 // Initializes |this| from |response| given by the mtpd service. | |
575 void FileEntry::InitializeFromResponse(dbus::Response* response) { | |
576 dbus::MessageReader response_reader(response); | |
577 dbus::MessageReader array_reader(response); | |
578 if (!response_reader.PopArray(&array_reader)) { | |
579 LOG(ERROR) << "Invalid response: " << response->ToString(); | |
580 return; | |
581 } | |
582 // TODO(thestig): Rework this code using Protocol Buffers. crosbug.com/22626 | |
583 typedef std::map<std::string, dbus::MessageReader*> PropertiesMap; | |
584 PropertiesMap properties; | |
585 STLValueDeleter<PropertiesMap> properties_value_deleter(&properties); | |
586 while (array_reader.HasMoreData()) { | |
587 dbus::MessageReader* value_reader = new dbus::MessageReader(response); | |
588 dbus::MessageReader dict_entry_reader(response); | |
589 std::string key; | |
590 if (!array_reader.PopDictEntry(&dict_entry_reader) || | |
591 !dict_entry_reader.PopString(&key) || | |
592 !dict_entry_reader.PopVariant(value_reader)) { | |
593 LOG(ERROR) << "Invalid response: " << response->ToString(); | |
594 return; | |
595 } | |
596 properties[key] = value_reader; | |
597 } | |
598 | |
599 MaybePopString(properties[mtpd::kFileName], &file_name_); | |
600 MaybePopUint32(properties[mtpd::kItemId], &item_id_); | |
601 MaybePopUint32(properties[mtpd::kParentId], &parent_id_); | |
602 MaybePopUint64(properties[mtpd::kFileSize], &file_size_); | |
603 | |
604 int64 modification_date = -1; | |
605 if (MaybePopInt64(properties[mtpd::kModificationDate], &modification_date)) | |
606 modification_date_ = base::Time::FromTimeT(modification_date); | |
607 | |
608 uint16 file_type = FILE_TYPE_OTHER; | |
609 if (MaybePopUint16(properties[mtpd::kFileType], &file_type)) { | |
610 switch (file_type) { | |
611 case FILE_TYPE_FOLDER: | |
612 case FILE_TYPE_JPEG: | |
613 case FILE_TYPE_JFIF: | |
614 case FILE_TYPE_TIFF: | |
615 case FILE_TYPE_BMP: | |
616 case FILE_TYPE_GIF: | |
617 case FILE_TYPE_PICT: | |
618 case FILE_TYPE_PNG: | |
619 case FILE_TYPE_WINDOWSIMAGEFORMAT: | |
620 case FILE_TYPE_JP2: | |
621 case FILE_TYPE_JPX: | |
622 case FILE_TYPE_UNKNOWN: | |
623 file_type_ = static_cast<FileType>(file_type); | |
624 break; | |
625 default: | |
626 file_type_ = FILE_TYPE_OTHER; | |
627 break; | |
628 } | |
629 } | |
630 } | |
631 | |
632 //////////////////////////////////////////////////////////////////////////////// | 493 //////////////////////////////////////////////////////////////////////////////// |
633 // MediaTransferProtocolDaemonClient | 494 // MediaTransferProtocolDaemonClient |
634 | 495 |
635 MediaTransferProtocolDaemonClient::MediaTransferProtocolDaemonClient() {} | 496 MediaTransferProtocolDaemonClient::MediaTransferProtocolDaemonClient() {} |
636 | 497 |
637 MediaTransferProtocolDaemonClient::~MediaTransferProtocolDaemonClient() {} | 498 MediaTransferProtocolDaemonClient::~MediaTransferProtocolDaemonClient() {} |
638 | 499 |
639 // static | 500 // static |
640 MediaTransferProtocolDaemonClient* | 501 MediaTransferProtocolDaemonClient* |
641 MediaTransferProtocolDaemonClient::Create(DBusClientImplementationType type, | 502 MediaTransferProtocolDaemonClient::Create(DBusClientImplementationType type, |
642 dbus::Bus* bus) { | 503 dbus::Bus* bus) { |
643 if (type == REAL_DBUS_CLIENT_IMPLEMENTATION) | 504 if (type == REAL_DBUS_CLIENT_IMPLEMENTATION) |
644 return new MediaTransferProtocolDaemonClientImpl(bus); | 505 return new MediaTransferProtocolDaemonClientImpl(bus); |
645 DCHECK_EQ(STUB_DBUS_CLIENT_IMPLEMENTATION, type); | 506 DCHECK_EQ(STUB_DBUS_CLIENT_IMPLEMENTATION, type); |
646 return new MediaTransferProtocolDaemonClientStubImpl(); | 507 return new MediaTransferProtocolDaemonClientStubImpl(); |
647 } | 508 } |
648 | 509 |
649 } // namespace chromeos | 510 } // namespace chromeos |
satorux1
2012/09/01 01:03:50
139 lines removed. nice!
| |
OLD | NEW |