// Copyright 2021 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chromeos/ash/components/network/cellular_inhibitor.h"
#include <memory>
#include <sstream>
#include "base/functional/bind.h"
#include "base/functional/callback_helpers.h"
#include "base/metrics/histogram_functions.h"
#include "base/task/single_thread_task_runner.h"
#include "base/time/time.h"
#include "chromeos/ash/components/network/device_state.h"
#include "chromeos/ash/components/network/network_device_handler.h"
#include "chromeos/ash/components/network/network_state_handler.h"
#include "chromeos/ash/components/network/network_type_pattern.h"
#include "components/device_event_log/device_event_log.h"
#include "third_party/cros_system_api/dbus/shill/dbus-constants.h"
namespace ash {
namespace {
// Delay for first uninhibit retry attempt. Delay doubles for every
// subsequent attempt.
constexpr base::TimeDelta kUninhibitRetryDelay = base::Seconds(2);
// Timeout waiting for Cellular device scanning state to change
// to true and back to false.
constexpr base::TimeDelta kScanningChangeTimeout = base::Seconds(120);
} // namespace
CellularInhibitor::InhibitRequest::InhibitRequest(
InhibitReason inhibit_reason,
InhibitCallback inhibit_callback)
: inhibit_reason(inhibit_reason),
inhibit_callback(std::move(inhibit_callback)) {}
CellularInhibitor::InhibitRequest::~InhibitRequest() = default;
CellularInhibitor::InhibitLock::InhibitLock(base::OnceClosure unlock_callback)
: unlock_callback_(std::move(unlock_callback)) {}
CellularInhibitor::InhibitLock::~InhibitLock() {
std::move(unlock_callback_).Run();
}
// static
const base::TimeDelta CellularInhibitor::kInhibitPropertyChangeTimeout =
base::Seconds(5);
// static
void CellularInhibitor::RecordInhibitOperationResult(
InhibitOperationResult result) {
base::UmaHistogramEnumeration("Network.Cellular.InhibitResult", result);
}
CellularInhibitor::CellularInhibitor() = default;
CellularInhibitor::~CellularInhibitor() = default;
void CellularInhibitor::Init(NetworkStateHandler* network_state_handler,
NetworkDeviceHandler* network_device_handler) {
network_state_handler_ = network_state_handler;
network_device_handler_ = network_device_handler;
network_state_handler_observer_.Observe(network_state_handler_.get());
}
void CellularInhibitor::InhibitCellularScanning(InhibitReason reason,
InhibitCallback callback) {
inhibit_requests_.push(
std::make_unique<InhibitRequest>(reason, std::move(callback)));
ProcessRequests();
}
std::optional<CellularInhibitor::InhibitReason>
CellularInhibitor::GetInhibitReason() const {
if (state_ == State::kIdle)
return std::nullopt;
return inhibit_requests_.front()->inhibit_reason;
}
void CellularInhibitor::AddObserver(Observer* observer) {
observer_list_.AddObserver(observer);
}
void CellularInhibitor::RemoveObserver(Observer* observer) {
observer_list_.RemoveObserver(observer);
}
bool CellularInhibitor::HasObserver(Observer* observer) const {
return observer_list_.HasObserver(observer);
}
void CellularInhibitor::NotifyInhibitStateChanged() {
for (auto& observer : observer_list_)
observer.OnInhibitStateChanged();
}
void CellularInhibitor::DeviceListChanged() {
CheckScanningIfNeeded();
}
void CellularInhibitor::DevicePropertiesUpdated(const DeviceState* device) {
CheckScanningIfNeeded();
CheckInhibitPropertyIfNeeded();
}
const DeviceState* CellularInhibitor::GetCellularDevice() const {
return network_state_handler_->GetDeviceStateByType(
NetworkTypePattern::Cellular());
}
void CellularInhibitor::TransitionToState(State state) {
State old_state = state_;
state_ = state;
bool was_inhibited = old_state != State::kIdle;
bool is_inhibited = state_ != State::kIdle;
std::stringstream ss;
ss << "CellularInhibitor state: " << old_state << " => " << state_;
if (!is_inhibited) {
DCHECK(!GetInhibitReason());
NET_LOG(EVENT) << ss.str();
} else {
NET_LOG(EVENT) << ss.str() << ", reason: " << *GetInhibitReason();
}
if (was_inhibited != is_inhibited)
NotifyInhibitStateChanged();
}
void CellularInhibitor::ProcessRequests() {
if (inhibit_requests_.empty())
return;
// Another inhibit request is already underway; wait until it has completed
// before starting a new request.
if (state_ != State::kIdle)
return;
uninhibit_attempts_so_far_ = 0;
TransitionToState(State::kInhibiting);
SetInhibitProperty();
}
void CellularInhibitor::OnInhibit(
bool success,
std::optional<CellularInhibitor::InhibitOperationResult> result) {
DCHECK(state_ == State::kWaitForInhibit || state_ == State::kInhibiting);
if (success) {
TransitionToState(State::kInhibited);
std::unique_ptr<InhibitLock> lock = std::make_unique<InhibitLock>(
base::BindOnce(&CellularInhibitor::AttemptUninhibit,
weak_ptr_factory_.GetWeakPtr()));
std::move(inhibit_requests_.front()->inhibit_callback).Run(std::move(lock));
return;
}
DCHECK(result.has_value());
RecordInhibitOperationResult(*result);
std::move(inhibit_requests_.front()->inhibit_callback).Run(nullptr);
PopRequestAndProcessNext();
}
void CellularInhibitor::AttemptUninhibit() {
DCHECK(state_ == State::kInhibited);
TransitionToState(State::kUninhibiting);
SetInhibitProperty();
}
void CellularInhibitor::OnUninhibit(bool success) {
DCHECK(state_ == State::kWaitForUninhibit || state_ == State::kUninhibiting);
if (!success) {
base::TimeDelta retry_delay =
kUninhibitRetryDelay * (1 << uninhibit_attempts_so_far_);
NET_LOG(DEBUG) << "Uninhibit Failed. Retrying in " << retry_delay;
TransitionToState(State::kInhibited);
uninhibit_attempts_so_far_++;
base::SingleThreadTaskRunner::GetCurrentDefault()->PostDelayedTask(
FROM_HERE,
base::BindOnce(&CellularInhibitor::AttemptUninhibit,
weak_ptr_factory_.GetWeakPtr()),
retry_delay);
return;
}
scanning_change_timer_.Start(
FROM_HERE, kScanningChangeTimeout,
base::BindOnce(&CellularInhibitor::OnScanningChangeTimeout,
weak_ptr_factory_.GetWeakPtr()));
TransitionToState(State::kWaitingForScanningToStop);
CheckForScanningStopped();
}
void CellularInhibitor::CheckScanningIfNeeded() {
if (state_ != State::kWaitingForScanningToStop)
return;
else
CheckForScanningStopped();
}
void CellularInhibitor::CheckForScanningStopped() {
DCHECK(state_ == State::kWaitingForScanningToStop);
if (!HasScanningStopped())
return;
RecordInhibitOperationResult(InhibitOperationResult::kSuccess);
PopRequestAndProcessNext();
}
bool CellularInhibitor::HasScanningStopped() {
const DeviceState* cellular_device = GetCellularDevice();
if (!cellular_device)
return false;
return !cellular_device->scanning();
}
void CellularInhibitor::OnScanningChangeTimeout() {
NET_LOG(ERROR)
<< "Timeout waiting for cellular device scanning state to change.";
// Assume that inhibit has completed and continue processing other requests.
RecordInhibitOperationResult(InhibitOperationResult::kUninhibitTimeout);
PopRequestAndProcessNext();
}
void CellularInhibitor::PopRequestAndProcessNext() {
scanning_change_timer_.Stop();
inhibit_requests_.pop();
TransitionToState(State::kIdle);
ProcessRequests();
}
void CellularInhibitor::SetInhibitProperty() {
DCHECK(state_ == State::kInhibiting || state_ == State::kUninhibiting);
const DeviceState* cellular_device = GetCellularDevice();
if (!cellular_device) {
ReturnSetInhibitPropertyResult(/*success=*/false,
InhibitOperationResult::kSetInhibitNoDevice);
return;
}
bool new_inhibit_value = state_ == State::kInhibiting;
// If the new value is already set, return early.
if (cellular_device->inhibited() == new_inhibit_value) {
ReturnSetInhibitPropertyResult(/*success=*/true, /*result=*/std::nullopt);
return;
}
network_device_handler_->SetDeviceProperty(
cellular_device->path(), shill::kInhibitedProperty,
base::Value(new_inhibit_value),
base::BindOnce(&CellularInhibitor::OnSetPropertySuccess,
weak_ptr_factory_.GetWeakPtr()),
base::BindOnce(&CellularInhibitor::OnSetPropertyError,
weak_ptr_factory_.GetWeakPtr(),
/*attempted_inhibit=*/new_inhibit_value));
}
void CellularInhibitor::OnSetPropertySuccess() {
if (state_ == State::kInhibiting) {
TransitionToState(State::kWaitForInhibit);
} else if (state_ == State::kUninhibiting) {
TransitionToState(State::kWaitForUninhibit);
}
set_inhibit_timer_.Start(
FROM_HERE, kInhibitPropertyChangeTimeout,
base::BindOnce(&CellularInhibitor::OnInhibitPropertyChangeTimeout,
weak_ptr_factory_.GetWeakPtr()));
CheckInhibitPropertyIfNeeded();
}
void CellularInhibitor::OnSetPropertyError(bool attempted_inhibit,
const std::string& error_name) {
NET_LOG(ERROR) << (attempted_inhibit ? "Inhibit" : "Uninhibit")
<< "CellularScanning() failed: " << error_name;
ReturnSetInhibitPropertyResult(/*success=*/false,
InhibitOperationResult::kSetInhibitFailed);
}
void CellularInhibitor::ReturnSetInhibitPropertyResult(
bool success,
std::optional<CellularInhibitor::InhibitOperationResult> result) {
set_inhibit_timer_.Stop();
if (state_ == State::kInhibiting || state_ == State::kWaitForInhibit) {
OnInhibit(success, result);
return;
}
if (state_ == State::kUninhibiting || state_ == State::kWaitForUninhibit) {
OnUninhibit(success);
}
}
void CellularInhibitor::CheckInhibitPropertyIfNeeded() {
if (state_ != State::kWaitForInhibit && state_ != State::kWaitForUninhibit)
return;
const DeviceState* cellular_device = GetCellularDevice();
if (!cellular_device)
return;
if (state_ == State::kWaitForInhibit && !cellular_device->inhibited())
return;
if (state_ == State::kWaitForUninhibit && cellular_device->inhibited())
return;
ReturnSetInhibitPropertyResult(/*success=*/true, /*result=*/std::nullopt);
}
void CellularInhibitor::OnInhibitPropertyChangeTimeout() {
NET_LOG(EVENT) << "Timeout waiting for inhibit property change state "
<< state_;
ReturnSetInhibitPropertyResult(/*success=*/false,
InhibitOperationResult::kSetInhibitTimeout);
}
std::ostream& operator<<(std::ostream& stream,
const CellularInhibitor::State& state) {
switch (state) {
case CellularInhibitor::State::kIdle:
stream << "[Idle]";
break;
case CellularInhibitor::State::kInhibiting:
stream << "[Inhibiting]";
break;
case CellularInhibitor::State::kWaitForInhibit:
stream << "[Waiting for Inhibit property set]";
break;
case CellularInhibitor::State::kInhibited:
stream << "[Inhibited]";
break;
case CellularInhibitor::State::kUninhibiting:
stream << "[Uninhibiting]";
break;
case CellularInhibitor::State::kWaitForUninhibit:
stream << "[Waiting for Inhibit property clear]";
break;
case CellularInhibitor::State::kWaitingForScanningToStop:
stream << "[Waiting for scanning to stop]";
break;
}
return stream;
}
std::ostream& operator<<(
std::ostream& stream,
const CellularInhibitor::InhibitReason& inhibit_reason) {
switch (inhibit_reason) {
case CellularInhibitor::InhibitReason::kInstallingProfile:
stream << "[Installing profile]";
break;
case CellularInhibitor::InhibitReason::kRenamingProfile:
stream << "[Renaming profile]";
break;
case CellularInhibitor::InhibitReason::kRemovingProfile:
stream << "[Removing profile]";
break;
case CellularInhibitor::InhibitReason::kConnectingToProfile:
stream << "[Connecting to profile]";
break;
case CellularInhibitor::InhibitReason::kRefreshingProfileList:
stream << "[Refreshing profile list]";
break;
case CellularInhibitor::InhibitReason::kResettingEuiccMemory:
stream << "[Resetting EUICC memory]";
break;
case CellularInhibitor::InhibitReason::kDisablingProfile:
stream << "[Disabling profile]";
break;
case CellularInhibitor::InhibitReason::kRequestingAvailableProfiles:
stream << "[Requesting available profiles]";
break;
}
return stream;
}
} // namespace ash
Codebase Browser
chromium