mirror of
https://github.com/kidfromjupiter/nearby.git
synced 2026-09-16 15:36:12 -04:00
315 lines
11 KiB
C++
315 lines
11 KiB
C++
// Copyright 2022 Google LLC
|
|
//
|
|
// 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
|
|
//
|
|
// https://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.
|
|
|
|
#include "sharing/fake_nearby_sharing_service.h"
|
|
|
|
#include <cstdint>
|
|
#include <functional>
|
|
#include <memory>
|
|
#include <string>
|
|
#include <utility>
|
|
|
|
#include "location/nearby/sharing/lib/sync/sync_manager.h"
|
|
#include "absl/functional/any_invocable.h"
|
|
#include "absl/status/statusor.h"
|
|
#include "absl/strings/string_view.h"
|
|
#include "internal/base/file_path.h"
|
|
#include "internal/base/observer_list.h"
|
|
#include "internal/platform/clock.h"
|
|
#include "sharing/advertisement.h"
|
|
#include "sharing/attachment_container.h"
|
|
#include "sharing/certificates/nearby_share_certificate_manager.h"
|
|
#include "sharing/nearby_sharing_service.h"
|
|
#include "sharing/nearby_sharing_settings.h"
|
|
#include "sharing/outgoing_share_session.h"
|
|
#include "sharing/outgoing_targets_manager.h"
|
|
#include "sharing/share_target.h"
|
|
#include "sharing/share_target_discovered_callback.h"
|
|
#include "sharing/transfer_metadata.h"
|
|
#include "sharing/transfer_update_callback.h"
|
|
#include "sharing/wrapped_share_target_discovered_callback.h"
|
|
|
|
namespace nearby {
|
|
namespace sharing {
|
|
|
|
FakeNearbySharingService::FakeNearbySharingService()
|
|
: service_thread_(&clock_, /*count=*/1),
|
|
analytics_recorder_(/*vendor_id=*/0, /*event_logger=*/nullptr),
|
|
sync_manager_(std::make_unique<SyncManager>(&identity_rpc_client_,
|
|
&preference_manager_)),
|
|
outgoing_targets_manager_(std::make_unique<OutgoingTargetsManager>(
|
|
&clock_, &service_thread_, &connections_manager_,
|
|
&analytics_recorder_,
|
|
[this](const ShareTarget& target) {
|
|
FireShareTargetDiscovered(target);
|
|
},
|
|
[this](const ShareTarget& target) { FireShareTargetUpdated(target); },
|
|
[this](const ShareTarget& target) { FireShareTargetLost(target); },
|
|
/*transfer_update_callback=*/
|
|
[](OutgoingShareSession&, const TransferMetadata&) {})) {}
|
|
|
|
void FakeNearbySharingService::AddObserver(Observer* observer) {
|
|
observers_.AddObserver(observer);
|
|
}
|
|
|
|
void FakeNearbySharingService::RemoveObserver(Observer* observer) {
|
|
observers_.RemoveObserver(observer);
|
|
}
|
|
|
|
// Shutdown the Nearby Sharing service, and cleanup.
|
|
void FakeNearbySharingService::Shutdown(
|
|
std::function<void(StatusCodes)> status_codes_callback) {
|
|
status_codes_callback(StatusCodes::kOk);
|
|
}
|
|
|
|
// Registers a send surface for handling payload transfer status and device
|
|
// discovery.
|
|
void FakeNearbySharingService::RegisterSendSurface(
|
|
TransferUpdateCallback* transfer_callback,
|
|
ShareTargetDiscoveredCallback* discovery_callback, SendSurfaceState state,
|
|
Advertisement::BlockedVendorId blocked_vendor_id, bool disable_wifi_hotspot,
|
|
absl::AnyInvocable<void(StatusCodes)> status_codes_callback) {
|
|
if (state == SendSurfaceState::kForeground) {
|
|
foreground_send_surface_map_.insert(
|
|
{transfer_callback,
|
|
WrappedShareTargetDiscoveredCallback(
|
|
discovery_callback, blocked_vendor_id, disable_wifi_hotspot)});
|
|
} else {
|
|
background_send_surface_map_.insert(
|
|
{transfer_callback,
|
|
WrappedShareTargetDiscoveredCallback(
|
|
discovery_callback, blocked_vendor_id, disable_wifi_hotspot)});
|
|
}
|
|
|
|
status_codes_callback(StatusCodes::kOk);
|
|
}
|
|
|
|
// Unregisters the current send surface.
|
|
void FakeNearbySharingService::UnregisterSendSurface(
|
|
TransferUpdateCallback* transfer_callback,
|
|
absl::AnyInvocable<void(StatusCodes)> status_codes_callback) {
|
|
foreground_send_surface_map_.erase(transfer_callback);
|
|
background_send_surface_map_.erase(transfer_callback);
|
|
|
|
status_codes_callback(StatusCodes::kOk);
|
|
}
|
|
|
|
// Registers a receiver surface for handling payload transfer status.
|
|
void FakeNearbySharingService::RegisterReceiveSurface(
|
|
TransferUpdateCallback* transfer_callback, ReceiveSurfaceState state,
|
|
Advertisement::BlockedVendorId vendor_id,
|
|
absl::AnyInvocable<void(StatusCodes)> status_codes_callback) {
|
|
if (state == ReceiveSurfaceState::kForeground) {
|
|
foreground_receive_transfer_callbacks_.AddObserver(transfer_callback);
|
|
} else {
|
|
background_receive_transfer_callbacks_.AddObserver(transfer_callback);
|
|
}
|
|
|
|
status_codes_callback(StatusCodes::kOk);
|
|
}
|
|
|
|
// Unregisters the current receive surface.
|
|
void FakeNearbySharingService::UnregisterReceiveSurface(
|
|
TransferUpdateCallback* transfer_callback,
|
|
absl::AnyInvocable<void(StatusCodes)> status_codes_callback) {
|
|
foreground_receive_transfer_callbacks_.RemoveObserver(transfer_callback);
|
|
background_receive_transfer_callbacks_.RemoveObserver(transfer_callback);
|
|
status_codes_callback(StatusCodes::kOk);
|
|
}
|
|
|
|
// Unregisters all foreground receive surfaces.
|
|
void FakeNearbySharingService::ClearForegroundReceiveSurfaces(
|
|
absl::AnyInvocable<void(StatusCodes)> status_codes_callback) {
|
|
status_codes_callback(StatusCodes::kOk);
|
|
}
|
|
|
|
// Returns true if there is an ongoing file transfer.
|
|
bool FakeNearbySharingService::IsTransferring() const { return false; }
|
|
|
|
// Returns true if we are currently scanning for remote devices.
|
|
bool FakeNearbySharingService::IsScanning() const { return false; }
|
|
|
|
// Sends |attachments| to the remote |share_target|.
|
|
void FakeNearbySharingService::SendAttachments(
|
|
int64_t share_target_id,
|
|
std::unique_ptr<AttachmentContainer> attachment_container,
|
|
std::function<void(StatusCodes)> status_codes_callback) {
|
|
status_codes_callback(StatusCodes::kOk);
|
|
}
|
|
|
|
// Accepts incoming share from the remote |share_target|.
|
|
void FakeNearbySharingService::Accept(
|
|
int64_t share_target_id,
|
|
std::function<void(StatusCodes status_codes)> status_codes_callback) {
|
|
status_codes_callback(StatusCodes::kOk);
|
|
}
|
|
|
|
// Rejects incoming share from the remote |share_target|.
|
|
void FakeNearbySharingService::Reject(
|
|
int64_t share_target_id,
|
|
std::function<void(StatusCodes status_codes)> status_codes_callback) {
|
|
status_codes_callback(StatusCodes::kOk);
|
|
}
|
|
|
|
// Cancels outgoing shares to the remote |share_target|.
|
|
void FakeNearbySharingService::Cancel(
|
|
int64_t share_target_id,
|
|
std::function<void(StatusCodes status_codes)> status_codes_callback) {
|
|
status_codes_callback(StatusCodes::kOk);
|
|
}
|
|
|
|
void FakeNearbySharingService::InitiatePairing(
|
|
int64_t share_target_id, service::proto::BindingRequest::Type binding_type,
|
|
absl::AnyInvocable<void(StatusCodes status_codes) &&>
|
|
status_codes_callback) {
|
|
initiate_pairing_callbacks_[share_target_id] =
|
|
std::move(status_codes_callback);
|
|
}
|
|
|
|
std::string FakeNearbySharingService::Dump() const { return ""; }
|
|
|
|
NearbyShareSettings* FakeNearbySharingService::GetSettings() { return nullptr; }
|
|
|
|
NearbyShareCertificateManager*
|
|
FakeNearbySharingService::GetCertificateManager() {
|
|
return nullptr;
|
|
}
|
|
|
|
AccountManager* FakeNearbySharingService::GetAccountManager() {
|
|
return nullptr;
|
|
}
|
|
|
|
Clock& FakeNearbySharingService::GetClock() { return clock_; }
|
|
|
|
SyncManager& FakeNearbySharingService::sync_manager() { return *sync_manager_; }
|
|
|
|
OutgoingTargetsManager& FakeNearbySharingService::outgoing_targets_manager() {
|
|
return *outgoing_targets_manager_;
|
|
}
|
|
|
|
void FakeNearbySharingService::FireHighVisibilityChangeRequested() {
|
|
for (auto& observer : observers_.GetObservers()) {
|
|
observer->OnHighVisibilityChangeRequested();
|
|
}
|
|
}
|
|
|
|
void FakeNearbySharingService::FireHighVisibilityChanged(
|
|
bool in_high_visibility) {
|
|
for (auto& observer : observers_.GetObservers()) {
|
|
observer->OnHighVisibilityChanged(in_high_visibility);
|
|
}
|
|
}
|
|
|
|
void FakeNearbySharingService::FireStartAdvertisingFailure() {
|
|
for (auto& observer : observers_.GetObservers()) {
|
|
observer->OnStartAdvertisingFailure();
|
|
}
|
|
}
|
|
|
|
void FakeNearbySharingService::FireStartDiscoveryResult(bool success) {
|
|
for (auto& observer : observers_.GetObservers()) {
|
|
observer->OnStartDiscoveryResult(success);
|
|
}
|
|
}
|
|
|
|
void FakeNearbySharingService::FireSendTransferUpdate(
|
|
SendSurfaceState state, const ShareTarget& share_target,
|
|
const AttachmentContainer& attachment_container,
|
|
TransferMetadata transfer_metadata) {
|
|
if (state == SendSurfaceState::kForeground) {
|
|
for (auto& entry : foreground_send_surface_map_) {
|
|
entry.first->OnTransferUpdate(share_target, attachment_container,
|
|
transfer_metadata);
|
|
}
|
|
} else {
|
|
for (auto& entry : background_send_surface_map_) {
|
|
entry.first->OnTransferUpdate(share_target, attachment_container,
|
|
transfer_metadata);
|
|
}
|
|
}
|
|
}
|
|
|
|
void FakeNearbySharingService::FireReceiveTransferUpdate(
|
|
ReceiveSurfaceState state, const ShareTarget& share_target,
|
|
const AttachmentContainer& attachment_container,
|
|
TransferMetadata transfer_metadata) {
|
|
if (state == ReceiveSurfaceState::kForeground) {
|
|
for (auto& transfer_callback :
|
|
foreground_receive_transfer_callbacks_.GetObservers()) {
|
|
transfer_callback->OnTransferUpdate(share_target, attachment_container,
|
|
transfer_metadata);
|
|
}
|
|
} else {
|
|
for (auto& transfer_callback :
|
|
foreground_receive_transfer_callbacks_.GetObservers()) {
|
|
transfer_callback->OnTransferUpdate(share_target, attachment_container,
|
|
transfer_metadata);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Fire discovery events.
|
|
void FakeNearbySharingService::FireShareTargetDiscovered(
|
|
ShareTarget share_target) {
|
|
for (auto& entry : foreground_send_surface_map_) {
|
|
entry.second.OnShareTargetDiscovered(share_target);
|
|
}
|
|
for (auto& entry : background_send_surface_map_) {
|
|
entry.second.OnShareTargetDiscovered(share_target);
|
|
}
|
|
}
|
|
|
|
void FakeNearbySharingService::FireShareTargetUpdated(
|
|
ShareTarget share_target) {
|
|
for (auto& entry : foreground_send_surface_map_) {
|
|
entry.second.OnShareTargetUpdated(share_target);
|
|
}
|
|
for (auto& entry : background_send_surface_map_) {
|
|
entry.second.OnShareTargetUpdated(share_target);
|
|
}
|
|
}
|
|
|
|
void FakeNearbySharingService::FireShareTargetLost(ShareTarget share_target) {
|
|
for (auto& entry : foreground_send_surface_map_) {
|
|
entry.second.OnShareTargetLost(share_target);
|
|
}
|
|
for (auto& entry : background_send_surface_map_) {
|
|
entry.second.OnShareTargetLost(share_target);
|
|
}
|
|
}
|
|
|
|
void FakeNearbySharingService::FireInitiatePairingResult(
|
|
int64_t share_target_id, StatusCodes status) {
|
|
auto it = initiate_pairing_callbacks_.find(share_target_id);
|
|
if (it == initiate_pairing_callbacks_.end()) {
|
|
return;
|
|
}
|
|
auto callback = std::move(it->second);
|
|
initiate_pairing_callbacks_.erase(it);
|
|
std::move(callback)(status);
|
|
}
|
|
|
|
void FakeNearbySharingService::UpdateBackupSavePath(
|
|
absl::string_view binding_id, absl::string_view save_path,
|
|
absl::AnyInvocable<void(NearbySharingService::StatusCodes)>
|
|
status_codes_callback) {
|
|
absl::StatusOr<FilePath> status =
|
|
sync_manager_->UpdateSyncBindingDestinationDirectory(binding_id,
|
|
FilePath(save_path));
|
|
status_codes_callback(status.ok() ? StatusCodes::kOk : StatusCodes::kError);
|
|
}
|
|
|
|
} // namespace sharing
|
|
} // namespace nearby
|