// Copyright 2014 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#import "components/storage_monitor/image_capture_device.h"
#include <ImageCaptureCore/ImageCaptureCore.h>
#import <UniformTypeIdentifiers/UniformTypeIdentifiers.h>
#include "base/apple/bridging.h"
#include "base/apple/foundation_util.h"
#include "base/containers/adapters.h"
#include "base/files/file_util.h"
#include "base/functional/bind.h"
#include "base/memory/weak_ptr.h"
#include "base/task/task_traits.h"
#include "base/task/thread_pool.h"
#include "content/public/browser/browser_thread.h"
namespace storage_monitor {
namespace {
base::File::Error RenameFile(const base::FilePath& downloaded_filename,
const base::FilePath& desired_filename) {
bool success =
base::ReplaceFile(downloaded_filename, desired_filename, nullptr);
return success ? base::File::FILE_OK : base::File::FILE_ERROR_NOT_FOUND;
}
void ReturnRenameResultToListener(
base::WeakPtr<ImageCaptureDeviceListener> listener,
const std::string& name,
const base::File::Error& result) {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
if (listener) {
listener->DownloadedFile(name, result);
}
}
base::FilePath PathForCameraItem(ICCameraItem* item) {
std::string name = base::SysNSStringToUTF8(item.name);
std::vector<std::string> components;
ICCameraFolder* folder = item.parentFolder;
while (folder != nil) {
components.push_back(base::SysNSStringToUTF8(folder.name));
folder = folder.parentFolder;
}
base::FilePath path;
for (const std::string& component : base::Reversed(components)) {
path = path.Append(component);
}
path = path.Append(name);
return path;
}
} // namespace
} // namespace storage_monitor
@implementation ImageCaptureDevice {
ICCameraDevice* __strong _camera;
base::WeakPtr<storage_monitor::ImageCaptureDeviceListener> _listener;
bool _closing;
}
- (instancetype)initWithCameraDevice:(ICCameraDevice*)cameraDevice {
if ((self = [super init])) {
_camera = cameraDevice;
_camera.delegate = self;
}
return self;
}
- (void)dealloc {
// Make sure the session was closed and listener set to null
// before destruction.
DCHECK(!_camera.delegate);
DCHECK(!_listener);
}
- (void)setListener:(base::WeakPtr<storage_monitor::ImageCaptureDeviceListener>)
listener {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
_listener = listener;
}
- (void)open {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
DCHECK(_listener);
[_camera requestOpenSession];
}
- (void)close {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
_closing = true;
[_camera cancelDownload];
[_camera requestCloseSession];
_camera.delegate = nil;
_listener.reset();
}
- (void)eject {
[_camera requestEject];
}
- (void)downloadFile:(const std::string&)name
localPath:(const base::FilePath&)localPath {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
// Find the file with that name and start download.
for (ICCameraItem* item in _camera.mediaFiles) {
std::string itemName = storage_monitor::PathForCameraItem(item).value();
if (itemName == name) {
// To create save options for ImageCapture, we need to split the target
// filename into directory/name and encode the directory as a URL.
NSURL* saveDirectory = base::apple::FilePathToNSURL(localPath.DirName());
NSString* saveFilename =
base::apple::FilePathToNSString(localPath.BaseName());
NSDictionary* options = @{
ICDownloadsDirectoryURL : saveDirectory,
ICSaveAsFilename : saveFilename,
ICOverwrite : @YES,
};
[_camera
requestDownloadFile:base::apple::ObjCCastStrict<ICCameraFile>(item)
options:options
downloadDelegate:self
didDownloadSelector:@selector(didDownloadFile:
error:options:contextInfo:)
contextInfo:nullptr];
return;
}
}
if (_listener) {
_listener->DownloadedFile(name, base::File::FILE_ERROR_NOT_FOUND);
}
}
// ----- ICDeviceDelegate (super-protocol of ICCameraDeviceDelegate) -----
- (void)didRemoveDevice:(ICDevice*)device {
device.delegate = nullptr;
if (_listener) {
_listener->DeviceRemoved();
}
}
// Notifies that a session was opened with the given device; potentially
// with an error.
- (void)device:(ICDevice*)device didOpenSessionWithError:(NSError*)error {
if (error) {
[self didRemoveDevice:_camera];
}
}
- (void)device:(ICDevice*)device didEncounterError:(NSError*)error {
if (error && _listener) {
_listener->DeviceRemoved();
}
}
// Various ICDeviceDelegate calls that are not used but need to exist as part of
// a full delegate implementation.
- (void)device:(ICDevice*)device didCloseSessionWithError:(NSError*)error {
}
// ----- ICCameraDeviceDelegate -----
- (void)cameraDevice:(ICCameraDevice*)camera
didAddItems:(NSArray<ICCameraItem*>*)items {
for (ICCameraItem* item in items) {
base::File::Info info;
if ([item.UTI isEqualToString:UTTypeFolder.identifier]) {
info.is_directory = true;
} else {
info.size = base::apple::ObjCCastStrict<ICCameraFile>(item).fileSize;
}
base::FilePath path = storage_monitor::PathForCameraItem(item);
info.last_modified = base::Time::FromNSDate(item.modificationDate);
info.creation_time = base::Time::FromNSDate(item.creationDate);
info.last_accessed = info.last_modified;
if (_listener) {
_listener->ItemAdded(path.value(), info);
}
}
}
// When this message is received, all media metadata is now loaded.
- (void)deviceDidBecomeReadyWithCompleteContentCatalog:(ICDevice*)device {
if (_listener) {
_listener->NoMoreItems();
}
}
// Various ICCameraDeviceDelegate calls that are not used but need to exist as
// part of a full delegate implementation.
- (void)cameraDevice:(ICCameraDevice*)camera didRemoveItems:(NSArray*)items {
}
- (void)cameraDevice:(ICCameraDevice*)camera
didReceiveThumbnail:(CGImageRef)thumbnail
forItem:(ICCameraItem*)item
error:(NSError*)error {
}
- (void)cameraDevice:(ICCameraDevice*)camera
didReceiveMetadata:(NSDictionary*)metadata
forItem:(ICCameraItem*)item
error:(NSError*)error {
}
- (void)cameraDevice:(ICCameraDevice*)camera
didRenameItems:(NSArray<ICCameraItem*>*)items {
}
- (void)cameraDeviceDidChangeCapability:(ICCameraDevice*)camera {
}
- (void)cameraDevice:(ICCameraDevice*)camera
didReceivePTPEvent:(NSData*)eventData {
}
- (void)cameraDeviceDidRemoveAccessRestriction:(ICDevice*)device {
}
- (void)cameraDeviceDidEnableAccessRestriction:(ICDevice*)device {
}
// ----- ICCameraDeviceDownloadDelegate -----
- (void)didDownloadFile:(ICCameraFile*)file
error:(NSError*)error
options:(NSDictionary*)options
contextInfo:(void*)contextInfo {
if (_closing) {
return;
}
std::string name = storage_monitor::PathForCameraItem(file).value();
if (error) {
DVLOG(1) << "error..."
<< base::SysNSStringToUTF8(error.localizedDescription);
if (_listener) {
_listener->DownloadedFile(name, base::File::FILE_ERROR_FAILED);
}
return;
}
std::string savedFilename = base::SysNSStringToUTF8(options[ICSavedFilename]);
std::string saveAsFilename =
base::SysNSStringToUTF8(options[ICSaveAsFilename]);
if (savedFilename == saveAsFilename) {
if (_listener) {
_listener->DownloadedFile(name, base::File::FILE_OK);
}
return;
}
// ImageCapture did not save the file into the name we gave it in the
// options. It picks a new name according to its best lights, so we need
// to rename the file.
base::FilePath saveDir(
base::SysNSStringToUTF8([options[ICDownloadsDirectoryURL] path]));
base::FilePath saveAsPath = saveDir.Append(saveAsFilename);
base::FilePath savedPath = saveDir.Append(savedFilename);
// Shared result value from file-copy closure to tell-listener closure.
// This is worth blocking shutdown, as otherwise a file that has been
// downloaded will be incorrectly named.
base::ThreadPool::PostTaskAndReplyWithResult(
FROM_HERE,
{base::MayBlock(), base::TaskPriority::BEST_EFFORT,
base::TaskShutdownBehavior::BLOCK_SHUTDOWN},
base::BindOnce(&storage_monitor::RenameFile, savedPath, saveAsPath),
base::BindOnce(&storage_monitor::ReturnRenameResultToListener, _listener,
name));
}
@end // ImageCaptureDevice
Codebase Browser
chromium