// Copyright 2020 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CHROME_BROWSER_ASH_SCANNING_SCAN_SERVICE_H_
#define CHROME_BROWSER_ASH_SCANNING_SCAN_SERVICE_H_
#include <cstdint>
#include <memory>
#include <optional>
#include <string>
#include <vector>
#include "ash/webui/scanning/mojom/scanning.mojom.h"
#include "base/cancelable_callback.h"
#include "base/containers/flat_map.h"
#include "base/files/file_path.h"
#include "base/memory/raw_ptr.h"
#include "base/memory/scoped_refptr.h"
#include "base/memory/weak_ptr.h"
#include "base/time/time.h"
#include "base/unguessable_token.h"
#include "chrome/browser/ash/scanning/scanning_file_path_helper.h"
#include "chromeos/ash/components/dbus/lorgnette/lorgnette_service.pb.h"
#include "components/keyed_service/core/keyed_service.h"
#include "mojo/public/cpp/bindings/pending_receiver.h"
#include "mojo/public/cpp/bindings/pending_remote.h"
#include "mojo/public/cpp/bindings/receiver.h"
#include "mojo/public/cpp/bindings/remote.h"
#include "services/device/wake_lock/power_save_blocker/power_save_blocker.h"
namespace base {
class SequencedTaskRunner;
} // namespace base
namespace content {
class BrowserContext;
} // namespace content
namespace ash {
class LorgnetteScannerManager;
// Implementation of the ash::scanning::mojom::ScanService interface. Used
// by the scanning WebUI (chrome://scanning) to get connected scanners, obtain
// scanner capabilities, and perform scans.
class ScanService : public scanning::mojom::ScanService,
public scanning::mojom::MultiPageScanController,
public KeyedService {
public:
ScanService(LorgnetteScannerManager* lorgnette_scanner_manager,
base::FilePath my_files_path,
base::FilePath google_drive_path,
content::BrowserContext* context);
~ScanService() override;
ScanService(const ScanService&) = delete;
ScanService& operator=(const ScanService&) = delete;
// scanning::mojom::ScanService:
void GetScanners(GetScannersCallback callback) override;
void GetScannerCapabilities(const base::UnguessableToken& scanner_id,
GetScannerCapabilitiesCallback callback) override;
void StartScan(const base::UnguessableToken& scanner_id,
scanning::mojom::ScanSettingsPtr settings,
mojo::PendingRemote<scanning::mojom::ScanJobObserver> observer,
StartScanCallback callback) override;
void StartMultiPageScan(
const base::UnguessableToken& scanner_id,
scanning::mojom::ScanSettingsPtr settings,
mojo::PendingRemote<scanning::mojom::ScanJobObserver> observer,
StartMultiPageScanCallback callback) override;
void CancelScan() override;
// scanning::mojom::MultiPageScanController:
void ScanNextPage(const base::UnguessableToken& scanner_id,
scanning::mojom::ScanSettingsPtr settings,
ScanNextPageCallback callback) override;
void RemovePage(uint32_t page_index) override;
void RescanPage(const base::UnguessableToken& scanner_id,
scanning::mojom::ScanSettingsPtr settings,
uint32_t page_index,
ScanNextPageCallback callback) override;
void CompleteMultiPageScan() override;
// Binds receiver_ by consuming |pending_receiver|.
void BindInterface(
mojo::PendingReceiver<scanning::mojom::ScanService> pending_receiver);
// Returns |scanned_images_| to verify the correct images are added/removed in
// unit tests.
std::vector<std::string> GetScannedImagesForTesting() const;
private:
// KeyedService:
void Shutdown() override;
// Processes the result of calling LorgnetteScannerManager::GetScannerNames().
void OnScannerNamesReceived(GetScannersCallback callback,
std::vector<std::string> scanner_names);
// Processes the result of calling
// LorgnetteScannerManager::GetScannerCapabilities().
void OnScannerCapabilitiesReceived(
GetScannerCapabilitiesCallback callback,
const std::optional<lorgnette::ScannerCapabilities>& capabilities);
// Receives progress updates after calling LorgnetteScannerManager::Scan().
// |page_number| indicates the page the |progress_percent| corresponds to.
void OnProgressPercentReceived(uint32_t progress_percent,
uint32_t page_number);
// Processes each |scanned_image| received after calling
// LorgnetteScannerManager::Scan(). |scan_to_path| is where images will be
// saved, and |file_type| specifies the file type to use when saving scanned
// images. If |page_index_to_replace| exists then |scanned_image| will replace
// an existing scanned image instead of being appended.
void OnPageReceived(const base::FilePath& scan_to_path,
const scanning::mojom::FileType file_type,
const std::optional<uint32_t> page_index_to_replace,
std::string scanned_image,
uint32_t page_number);
// Processes the final result of calling LorgnetteScannerManager::Scan().
// |failure_mode| is set to SCAN_FAILURE_MODE_NO_FAILURE when the scan
// succeeds; otherwise, its value indicates what caused the scan to fail.
void OnScanCompleted(bool is_multi_page_scan,
lorgnette::ScanFailureMode failure_mode);
// For a multi-page scan, when a page scan completes, report a failure if it
// exists.
void OnMultiPageScanPageCompleted(lorgnette::ScanFailureMode failure_mode);
// Processes the final result of calling
// LorgnetteScannerManager::CancelScan().
void OnCancelCompleted(bool success);
// Called once the task runner finishes saving a PDF file.
void OnPdfSaved(const bool success);
// Called once the task runner finishes saving a page of a scan.
void OnPageSaved(const base::FilePath& saved_file_path);
// Sends the scan request to the scanner.
bool SendScanRequest(
const base::UnguessableToken& scanner_id,
scanning::mojom::ScanSettingsPtr settings,
const std::optional<uint32_t> page_index_to_replace,
base::OnceCallback<void(lorgnette::ScanFailureMode failure_mode)>
completion_callback);
// Called once the task runner finishes saving the last page of a scan.
void OnAllPagesSaved(lorgnette::ScanFailureMode failure_mode);
// Sets the local member variables back to their initial empty state.
void ClearScanState();
// Sets the ScanJobOberver for a new scan.
void SetScanJobObserver(
mojo::PendingRemote<scanning::mojom::ScanJobObserver> observer);
// Resets the mojo::Receiver |multi_page_controller_receiver_|.
void ResetMultiPageScanController();
// Determines whether the service supports saving scanned images to
// |file_path|.
bool FilePathSupported(const base::FilePath& file_path);
// Returns the scanner name corresponding to the given |scanner_id| or an
// empty string if the name cannot be found.
std::string GetScannerName(const base::UnguessableToken& scanner_id);
// Map of scanner IDs to display names. Used to pass the correct display name
// to LorgnetteScannerManager when clients provide an ID.
base::flat_map<base::UnguessableToken, std::string> scanner_names_;
// Receives and dispatches method calls to this implementation of the
// ash::scanning::mojom::ScanService interface.
mojo::Receiver<scanning::mojom::ScanService> receiver_{this};
// Receives and dispatches method calls to this implementation of the
// ash::scanning::mojom::MultiPageScanController interface.
mojo::Receiver<scanning::mojom::MultiPageScanController>
multi_page_controller_receiver_{this};
// Used to send scan job events to an observer. The remote is bound when a
// scan job is started and is disconnected when the scan job is complete.
mojo::Remote<scanning::mojom::ScanJobObserver> scan_job_observer_;
// Unowned. Used to get scanner information and perform scans.
raw_ptr<LorgnetteScannerManager> lorgnette_scanner_manager_;
// The browser context from which scans are initiated.
const raw_ptr<content::BrowserContext> context_;
// Indicates whether there was a failure to save scanned images.
bool page_save_failed_;
// The scanned images used to create a multipage PDF.
std::vector<std::string> scanned_images_;
// The time a scan was started. Used in filenames when saving scanned images.
base::Time start_time_;
// The file paths of the pages scanned in a scan job.
std::vector<base::FilePath> scanned_file_paths_;
// Task runner used to convert and save scanned images.
scoped_refptr<base::SequencedTaskRunner> task_runner_;
// Tracks the number of pages scanned for histogram recording.
int num_pages_scanned_;
// Indicates whether alternate pages must be rotated to account for an ADF
// scanner that flips them.
bool rotate_alternate_pages_;
// Stores the dots per inch (DPI) of the requested scan.
std::optional<int> scan_dpi_;
// The time at which GetScanners() is called. Used to record the time between
// a user launching the Scan app and being able to interact with it.
base::TimeTicks get_scanners_time_;
// The time a multi-page scan session starts. Used to record the duration of a
// multi-page scan session.
base::TimeTicks multi_page_start_time_;
// Helper class for for file path manipulation and verification.
ScanningFilePathHelper file_path_helper_;
// Wake lock to ensure system does not suspend during a scan job.
std::unique_ptr<device::PowerSaveBlocker> wake_lock_;
// Called if there is no response from the scanner after a timeout. Used to
// ensure the wake lock will be released if there is an error from the
// scanner or backend.
base::CancelableOnceCallback<void(ScanService*, bool,
lorgnette::ScanFailureMode)> timeout_callback_;
// Needs to be last member variable.
base::WeakPtrFactory<ScanService> weak_ptr_factory_{this};
};
} // namespace ash
#endif // CHROME_BROWSER_ASH_SCANNING_SCAN_SERVICE_H_
Codebase Browser
chromium