// Copyright 2023 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/browser/ui/webui/nearby_internals/nearby_internals_ui_presence_handler.h"
#include "base/containers/contains.h"
#include "chrome/browser/ash/nearby/nearby_process_manager_factory.h"
#include "chrome/browser/ash/nearby/presence/nearby_presence_service_factory.h"
#include "chrome/browser/profiles/profile.h"
#include "chrome/browser/push_notification/push_notification_service_factory.h"
#include "chromeos/ash/components/nearby/presence/credentials/prefs.h"
#include "chromeos/ash/components/nearby/presence/nearby_presence_service.h"
#include "chromeos/ash/services/nearby/public/mojom/nearby_share_settings.mojom.h"
#include "components/cross_device/logging/logging.h"
#include "components/prefs/pref_service.h"
#include "components/push_notification/push_notification_service.h"
namespace {
// Keys in the JSON representation of a device.
const char kDeviceNameKey[] = "name";
const char kTypeKey[] = "type";
const char kEndpointKey[] = "endpoint_id";
const char kActionsKey[] = "actions";
// ActionType strings representations.
const char kCallTransferAction[] = "Call Transfer";
const char kActiveUnlockAction[] = "Active Unlock";
const char kNearbyShareAction[] = "Nearby Share";
const char kInstantTetheringAction[] = "Instant Tethering";
const char kPhoneHubAction[] = "Phone Hub";
const char kPresenceManagerAction[] = "Presence Manager";
const char kFinderAction[] = "Finder";
const char kFastPairSassAction[] = "Fast Pair Sass";
const char kTapToTransferAction[] = "Tap To Transfer";
const char kLastAction[] = "Invalid Action";
// `PushNotificationMessage` key value pairs
const char kNotificationTypeIdKey[] = "type_id";
const char kNotificationClientIdKey[] = "client_id";
const char kNotificationClientIdValue[] = "nearby";
std::string PresenceActionToString(nearby::presence::PresenceAction action) {
switch (nearby::presence::ActionBit(action.GetActionIdentifier())) {
case nearby::presence::ActionBit::kCallTransferAction:
return kCallTransferAction;
case nearby::presence::ActionBit::kActiveUnlockAction:
return kActiveUnlockAction;
case nearby::presence::ActionBit::kNearbyShareAction:
return kNearbyShareAction;
case nearby::presence::ActionBit::kInstantTetheringAction:
return kInstantTetheringAction;
case nearby::presence::ActionBit::kPhoneHubAction:
return kPhoneHubAction;
case nearby::presence::ActionBit::kPresenceManagerAction:
return kPresenceManagerAction;
case nearby::presence::ActionBit::kFinderAction:
return kFinderAction;
case nearby::presence::ActionBit::kFastPairSassAction:
return kFastPairSassAction;
case nearby::presence::ActionBit::kTapToTransferAction:
return kTapToTransferAction;
case nearby::presence::ActionBit::kLastAction:
return kLastAction;
}
}
// Converts |presence_device| to a raw dictionary value used as a JSON argument
// to JavaScript functions.
base::Value::Dict PresenceDeviceToDictionary(
nearby::presence::PresenceDevice presence_device) {
base::Value::Dict dictionary;
dictionary.Set(kDeviceNameKey,
presence_device.GetDeviceIdentityMetadata().device_name());
// TODO(b/277820435): add other device type options.
if (presence_device.GetDeviceIdentityMetadata().device_type() ==
nearby::internal::DeviceType::DEVICE_TYPE_PHONE) {
dictionary.Set(kTypeKey, "DEVICE_TYPE_PHONE");
}
dictionary.Set(kEndpointKey, presence_device.GetEndpointId());
std::string actions_list;
for (auto action : presence_device.GetActions()) {
actions_list += PresenceActionToString(action);
actions_list += ", ";
}
// Remove the trailing comma and whitespace.
actions_list.pop_back();
actions_list.pop_back();
dictionary.Set(kActionsKey, actions_list);
return dictionary;
}
} // namespace
NearbyInternalsPresenceHandler::NearbyInternalsPresenceHandler(
content::BrowserContext* context)
: context_(context) {}
NearbyInternalsPresenceHandler::~NearbyInternalsPresenceHandler() = default;
void NearbyInternalsPresenceHandler::RegisterMessages() {
web_ui()->RegisterMessageCallback(
"InitializePresenceHandler",
base::BindRepeating(&NearbyInternalsPresenceHandler::Initialize,
base::Unretained(this)));
web_ui()->RegisterMessageCallback(
"StartPresenceScan",
base::BindRepeating(
&NearbyInternalsPresenceHandler::HandleStartPresenceScan,
base::Unretained(this)));
web_ui()->RegisterMessageCallback(
"StopPresenceScan",
base::BindRepeating(
&NearbyInternalsPresenceHandler::HandleStopPresenceScan,
base::Unretained(this)));
web_ui()->RegisterMessageCallback(
"SyncPresenceCredentials",
base::BindRepeating(
&NearbyInternalsPresenceHandler::HandleSyncPresenceCredentials,
base::Unretained(this)));
web_ui()->RegisterMessageCallback(
"FirstTimePresenceFlow",
base::BindRepeating(
&NearbyInternalsPresenceHandler::HandleFirstTimePresenceFlow,
base::Unretained(this)));
web_ui()->RegisterMessageCallback(
"ConnectToPresenceDevice",
base::BindRepeating(
&NearbyInternalsPresenceHandler::HandleConnectToPresenceDevice,
base::Unretained(this)));
web_ui()->RegisterMessageCallback(
"SendUpdateCredentialsMessage",
base::BindRepeating(
&NearbyInternalsPresenceHandler::HandleSendUpdateCredentialsMessage,
base::Unretained(this)));
}
void NearbyInternalsPresenceHandler::OnJavascriptAllowed() {}
void NearbyInternalsPresenceHandler::OnJavascriptDisallowed() {}
void NearbyInternalsPresenceHandler::Initialize(const base::Value::List& args) {
AllowJavascript();
}
void NearbyInternalsPresenceHandler::HandleStartPresenceScan(
const base::Value::List& args) {
ash::nearby::presence::NearbyPresenceService* service =
ash::nearby::presence::NearbyPresenceServiceFactory::GetForBrowserContext(
context_);
if (service) {
CD_LOG(VERBOSE, Feature::NEARBY_INFRA)
<< __func__ << ": NearbyPresenceService was retrieved successfully";
ash::nearby::presence::NearbyPresenceService::ScanFilter filter(
nearby::internal::IdentityType::IDENTITY_TYPE_PRIVATE_GROUP,
/*actions=*/{});
service->StartScan(
filter, /*scan_delegate=*/this,
base::BindOnce(&NearbyInternalsPresenceHandler::OnScanStarted,
weak_ptr_factory_.GetWeakPtr()));
}
}
void NearbyInternalsPresenceHandler::HandleStopPresenceScan(
const base::Value::List& args) {
scan_session_.reset();
}
void NearbyInternalsPresenceHandler::HandleSyncPresenceCredentials(
const base::Value::List& args) {
ash::nearby::presence::NearbyPresenceService* service =
ash::nearby::presence::NearbyPresenceServiceFactory::GetForBrowserContext(
context_);
if (service) {
CD_LOG(VERBOSE, Feature::NEARBY_INFRA)
<< __func__ << ": NearbyPresenceService was retrieved successfully";
service->UpdateCredentials();
}
}
void NearbyInternalsPresenceHandler::HandleFirstTimePresenceFlow(
const base::Value::List& args) {
ash::nearby::presence::NearbyPresenceService* service =
ash::nearby::presence::NearbyPresenceServiceFactory::GetForBrowserContext(
context_);
if (service) {
CD_LOG(VERBOSE, Feature::NEARBY_INFRA)
<< __func__ << ": NearbyPresenceService was retrieved successfully";
auto* pref_service = Profile::FromBrowserContext(context_)->GetPrefs();
// Reset the state that indicates that first time registration was
// completed for testing. This will trigger the first time flow in
// `NearbyPresenceService::Initialize()`, in the case that this was already
// set on the device for manual testing.
pref_service->SetBoolean(ash::nearby::presence::prefs::
kNearbyPresenceFirstTimeRegistrationComplete,
false);
service->Initialize(
base::BindOnce(&NearbyInternalsPresenceHandler::
OnNearbyPresenceCredentialManagerInitialized,
weak_ptr_factory_.GetWeakPtr()));
}
}
void NearbyInternalsPresenceHandler::OnScanStarted(
std::unique_ptr<ash::nearby::presence::NearbyPresenceService::ScanSession>
scan_session,
ash::nearby::presence::enums::StatusCode status) {
if (status == ash::nearby::presence::enums::StatusCode::kAbslOk) {
scan_session_ = std::move(scan_session);
CD_LOG(VERBOSE, Feature::NEARBY_INFRA)
<< __func__ << ": ScanSession remote successfully returned and bound.";
} else {
// TODO(b/276307539): Pass error status back to WebUI.
return;
}
}
void NearbyInternalsPresenceHandler::
OnNearbyPresenceCredentialManagerInitialized() {
CD_LOG(VERBOSE, Feature::NEARBY_INFRA) << __func__;
}
void NearbyInternalsPresenceHandler::OnPresenceDeviceFound(
nearby::presence::PresenceDevice presence_device) {
const std::string& endpoint_id = presence_device.GetEndpointId();
endpoint_id_to_presence_device_map_.emplace(
endpoint_id, std::make_unique<nearby::presence::PresenceDevice>(
std::move(presence_device)));
FireWebUIListener(
"presence-device-found",
PresenceDeviceToDictionary(
*endpoint_id_to_presence_device_map_.at(endpoint_id).get()));
}
void NearbyInternalsPresenceHandler::OnPresenceDeviceChanged(
nearby::presence::PresenceDevice presence_device) {
FireWebUIListener("presence-device-changed",
PresenceDeviceToDictionary(presence_device));
}
void NearbyInternalsPresenceHandler::OnPresenceDeviceLost(
nearby::presence::PresenceDevice presence_device) {
endpoint_id_to_presence_device_map_.erase(presence_device.GetEndpointId());
FireWebUIListener("presence-device-lost",
PresenceDeviceToDictionary(presence_device));
}
void NearbyInternalsPresenceHandler::OnScanSessionInvalidated() {
scan_session_.reset();
HandleStartPresenceScan(/*args=*/{});
}
void NearbyInternalsPresenceHandler::HandleConnectToPresenceDevice(
const base::Value::List& args) {
const std::string& endpoint_id = args[0].GetString();
CD_LOG(VERBOSE, Feature::NEARBY_INFRA)
<< __func__
<< ": Connection attempt for device with endpoint id: " << endpoint_id;
if (!base::Contains(endpoint_id_to_presence_device_map_, endpoint_id)) {
CD_LOG(WARNING, Feature::NEARBY_INFRA)
<< __func__ << ": Received endpoint_id for device no longer in map.";
return;
}
auto* presence_connections_manager = GetNearbyPresenceConnectionsManager();
if (presence_connections_manager) {
presence_connections_manager->ConnectV3(
*endpoint_id_to_presence_device_map_.at(endpoint_id).get(),
nearby_share::mojom::DataUsage::kOffline,
base::BindOnce(&NearbyInternalsPresenceHandler::OnConnection,
weak_ptr_factory_.GetWeakPtr(), endpoint_id));
}
}
void NearbyInternalsPresenceHandler::OnConnection(
const std::string& endpoint_id,
NearbyConnection* connection) {
// TODO(b/339674618): Add `Connected` / `Failed to Connect` label on device
// cell in the WebUI.
if (connection) {
CD_LOG(VERBOSE, Feature::NEARBY_INFRA)
<< "Successfully connected to endpoint_id=" << endpoint_id;
} else {
CD_LOG(WARNING, Feature::NEARBY_INFRA)
<< "Failed to connect to to endpoint_id=" << endpoint_id;
}
}
void NearbyInternalsPresenceHandler::HandleSendUpdateCredentialsMessage(
const base::Value::List& args) {
push_notification::PushNotificationService* service =
push_notification::PushNotificationServiceFactory::GetForBrowserContext(
context_);
CHECK(service);
push_notification::PushNotificationClientManager::PushNotificationMessage
message;
message.data.insert_or_assign(kNotificationTypeIdKey,
push_notification::kNearbyPresenceClientId);
message.data.insert_or_assign(kNotificationClientIdKey,
kNotificationClientIdValue);
service->GetPushNotificationClientManager()
->NotifyPushNotificationClientOfMessage(std::move(message));
}
ash::nearby::presence::NearbyPresenceConnectionsManager*
NearbyInternalsPresenceHandler::GetNearbyPresenceConnectionsManager() {
if (!nearby_presence_connections_manager_) {
ash::nearby::presence::NearbyPresenceService* service = ash::nearby::
presence::NearbyPresenceServiceFactory::GetForBrowserContext(context_);
if (service) {
CD_LOG(VERBOSE, Feature::NEARBY_INFRA)
<< __func__ << ": NearbyPresenceService was retrieved successfully";
nearby_presence_connections_manager_ =
service->CreateNearbyPresenceConnectionsManager();
}
}
return nearby_presence_connections_manager_.get();
}
Codebase Browser
chromium