// Copyright 2012 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/ash/mobile/mobile_activator.h"
#include <algorithm>
#include <map>
#include <string>
#include "base/files/file_util.h"
#include "base/functional/bind.h"
#include "base/functional/callback_helpers.h"
#include "base/json/json_reader.h"
#include "base/location.h"
#include "base/logging.h"
#include "base/memory/ref_counted_memory.h"
#include "base/metrics/histogram_macros.h"
#include "base/strings/string_util.h"
#include "base/strings/utf_string_conversions.h"
#include "base/threading/scoped_blocking_call.h"
#include "base/timer/timer.h"
#include "base/values.h"
#include "chromeos/ash/components/network/device_state.h"
#include "chromeos/ash/components/network/network_activation_handler.h"
#include "chromeos/ash/components/network/network_configuration_handler.h"
#include "chromeos/ash/components/network/network_connect.h"
#include "chromeos/ash/components/network/network_connection_handler.h"
#include "chromeos/ash/components/network/network_event_log.h"
#include "chromeos/ash/components/network/network_handler_callbacks.h"
#include "chromeos/ash/components/network/network_state.h"
#include "chromeos/ash/components/network/network_state_handler.h"
#include "content/public/browser/browser_task_traits.h"
#include "content/public/browser/browser_thread.h"
#include "third_party/cros_system_api/dbus/service_constants.h"
using content::BrowserThread;
namespace ash {
namespace {
// Number of times we'll try an OTASP before failing the activation process.
const int kMaxOTASPTries = 3;
// Number of times we will retry to reconnect and reload payment portal page.
const int kMaxPortalReconnectCount = 2;
// Time between connection attempts when forcing a reconnect.
const int kReconnectDelayMS = 3000;
// Retry delay after failed OTASP attempt.
const int kOTASPRetryDelay = 40000;
// Maximum amount of time we'll wait for a service to reconnect.
const int kMaxReconnectTime = 30000;
// Returns true if the device follows the simple activation flow.
bool IsSimpleActivationFlow(const NetworkState* network) {
return (network->activation_type() == shill::kActivationTypeNonCellular ||
network->activation_type() == shill::kActivationTypeOTA);
}
} // namespace
////////////////////////////////////////////////////////////////////////////////
//
// MobileActivator
//
////////////////////////////////////////////////////////////////////////////////
MobileActivator::MobileActivator()
: state_(PlanActivationState::kPageLoading),
terminated_(true),
connection_retry_count_(0),
initial_OTASP_attempts_(0),
trying_OTASP_attempts_(0),
final_OTASP_attempts_(0),
payment_reconnect_count_(0) {}
MobileActivator::~MobileActivator() {
TerminateActivation();
}
MobileActivator* MobileActivator::GetInstance() {
return base::Singleton<MobileActivator>::get();
}
void MobileActivator::TerminateActivation() {
state_duration_timer_.Stop();
continue_reconnect_timer_.Stop();
reconnect_timeout_timer_.Stop();
network_state_handler_observer_.Reset();
meid_.clear();
iccid_.clear();
service_path_.clear();
device_path_.clear();
state_ = PlanActivationState::kPageLoading;
terminated_ = true;
}
void MobileActivator::DefaultNetworkChanged(const NetworkState* network) {
RefreshCellularNetworks();
}
void MobileActivator::NetworkPropertiesUpdated(const NetworkState* network) {
if (state_ == PlanActivationState::kPageLoading)
return;
if (!network || network->type() != shill::kTypeCellular)
return;
const DeviceState* device =
NetworkHandler::Get()->network_state_handler()->GetDeviceState(
network->device_path());
if (!device) {
LOG(ERROR) << "Cellular device can't be found: " << network->device_path();
return;
}
if (network->device_path() != device_path_) {
LOG(WARNING) << "Ignoring property update for cellular service "
<< network->path() << " on unknown device "
<< network->device_path()
<< " (Stored device path = " << device_path_ << ")";
return;
}
// A modem reset leads to a new service path. Since we have verified that we
// are a cellular service on a still valid stored device path, update it.
service_path_ = network->path();
EvaluateCellularNetwork(network);
}
void MobileActivator::OnShuttingDown() {
network_state_handler_observer_.Reset();
}
void MobileActivator::AddObserver(MobileActivator::Observer* observer) {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
observers_.AddObserver(observer);
}
void MobileActivator::RemoveObserver(MobileActivator::Observer* observer) {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
observers_.RemoveObserver(observer);
}
void MobileActivator::InitiateActivation(const std::string& service_path) {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
const NetworkState* network = GetNetworkState(service_path);
if (!network) {
LOG(WARNING) << "Cellular service can't be found: " << service_path;
return;
}
const DeviceState* device =
NetworkHandler::Get()->network_state_handler()->GetDeviceState(
network->device_path());
if (!device) {
LOG(ERROR) << "Cellular device can't be found: " << network->device_path();
return;
}
DCHECK(network->Matches(NetworkTypePattern::Cellular()));
terminated_ = false;
meid_ = device->meid();
iccid_ = device->iccid();
service_path_ = service_path;
device_path_ = network->device_path();
ChangeState(network, PlanActivationState::kPageLoading,
ActivationError::kNone);
// We want shill to connect us after activations, so enable autoconnect.
base::Value::Dict auto_connect_property;
auto_connect_property.Set(shill::kAutoConnectProperty, true);
NetworkHandler::Get()->network_configuration_handler()->SetShillProperties(
service_path_, std::move(auto_connect_property), base::DoNothing(),
network_handler::ErrorCallback());
StartActivation();
}
void MobileActivator::GetPropertiesFailure(const std::string& error_name,
base::Value error_data) {
NET_LOG(ERROR) << "MobileActivator GetProperties failed for "
<< NetworkPathId(service_path_) << " Error: " << error_name;
}
void MobileActivator::OnSetTransactionStatus(bool success) {
content::GetUIThreadTaskRunner({})->PostTask(
FROM_HERE, base::BindOnce(&MobileActivator::HandleSetTransactionStatus,
weak_ptr_factory_.GetWeakPtr(), success));
}
void MobileActivator::HandleSetTransactionStatus(bool success) {
// The payment is received, try to reconnect and check the status all over
// again.
if (success && state_ == PlanActivationState::kShowingPayment) {
SignalCellularPlanPayment();
const NetworkState* network = GetNetworkState(service_path_);
if (network && IsSimpleActivationFlow(network)) {
state_ = PlanActivationState::kDone;
NetworkHandler::Get()->network_activation_handler()->CompleteActivation(
network->path(), base::DoNothing(), network_handler::ErrorCallback());
} else {
StartOTASP();
}
}
}
void MobileActivator::OnPortalLoaded(bool success) {
content::GetUIThreadTaskRunner({})->PostTask(
FROM_HERE, base::BindOnce(&MobileActivator::HandlePortalLoaded,
weak_ptr_factory_.GetWeakPtr(), success));
}
void MobileActivator::HandlePortalLoaded(bool success) {
const NetworkState* network = GetNetworkState(service_path_);
if (!network) {
ChangeState(nullptr, PlanActivationState::kError,
ActivationError::kNoCellularService);
return;
}
if (state_ == PlanActivationState::kPaymentPortalLoading ||
state_ == PlanActivationState::kShowingPayment) {
if (success) {
payment_reconnect_count_ = 0;
ChangeState(network, PlanActivationState::kShowingPayment,
ActivationError::kNone);
} else {
// There is no point in forcing reconnecting the cellular network if the
// activation should not be done over it.
if (network->activation_type() == shill::kActivationTypeNonCellular)
return;
payment_reconnect_count_++;
if (payment_reconnect_count_ > kMaxPortalReconnectCount) {
ChangeState(nullptr, PlanActivationState::kError,
ActivationError::kNoCellularService);
return;
}
// Reconnect and try and load the frame again.
ChangeState(network, PlanActivationState::kReconnecting,
ActivationError::kNone);
}
} else {
NOTREACHED_IN_MIGRATION()
<< "Called paymentPortalLoad while in unexpected state: "
<< GetStateDescription(state_);
}
}
void MobileActivator::StartOTASPTimer() {
state_duration_timer_.Start(FROM_HERE, base::Milliseconds(kOTASPRetryDelay),
this, &MobileActivator::HandleOTASPTimeout);
}
void MobileActivator::StartActivation() {
const NetworkState* network = GetNetworkState(service_path_);
// Check if we can start activation process.
if (!network) {
NetworkStateHandler::TechnologyState technology_state =
NetworkHandler::Get()->network_state_handler()->GetTechnologyState(
NetworkTypePattern::Cellular());
ActivationError error = ActivationError::kActivationFailed;
if (technology_state == NetworkStateHandler::TECHNOLOGY_UNAVAILABLE) {
error = ActivationError::kNoCellularDevice;
} else if (technology_state != NetworkStateHandler::TECHNOLOGY_ENABLED) {
error = ActivationError::kCellularDisabled;
} else {
error = ActivationError::kNoCellularService;
}
ChangeState(nullptr, PlanActivationState::kError, error);
return;
}
// Start monitoring network property changes.
network_state_handler_observer_.Observe(
NetworkHandler::Get()->network_state_handler());
if (network->activation_type() == shill::kActivationTypeNonCellular) {
StartActivationOverNonCellularNetwork();
} else if (network->activation_type() == shill::kActivationTypeOTA) {
StartActivationOTA();
} else if (network->activation_type() == shill::kActivationTypeOTASP) {
StartActivationOTASP();
}
}
void MobileActivator::StartActivationOverNonCellularNetwork() {
// Fast forward to payment portal loading.
const NetworkState* network = GetNetworkState(service_path_);
if (!network) {
LOG(WARNING) << "Cellular service can't be found: " << service_path_;
return;
}
ChangeState(network,
(network->activation_state() == shill::kActivationStateActivated)
? PlanActivationState::kDone
: PlanActivationState::kPaymentPortalLoading,
ActivationError::kNone);
RefreshCellularNetworks();
}
void MobileActivator::StartActivationOTA() {
// Connect to the network if we don't currently have access.
const NetworkState* network = GetNetworkState(service_path_);
if (!network) {
LOG(WARNING) << "Cellular service can't be found: " << service_path_;
return;
}
const NetworkState* default_network = GetDefaultNetwork();
bool is_online_or_portal =
default_network &&
(default_network->connection_state() == shill::kStateOnline ||
NetworkState::StateIsPortalled(default_network->connection_state()));
if (!is_online_or_portal)
ConnectNetwork(network);
ChangeState(network, PlanActivationState::kPaymentPortalLoading,
ActivationError::kNone);
RefreshCellularNetworks();
}
void MobileActivator::StartActivationOTASP() {
const NetworkState* network = GetNetworkState(service_path_);
if (!network) {
LOG(WARNING) << "Cellular service can't be found: " << service_path_;
return;
}
if (HasRecentCellularPlanPayment() &&
(network->activation_state() ==
shill::kActivationStatePartiallyActivated)) {
// Try to start with OTASP immediately if we have received payment recently.
state_ = PlanActivationState::kStartOTASP;
} else {
state_ = PlanActivationState::kStart;
}
EvaluateCellularNetwork(network);
}
void MobileActivator::RetryOTASP() {
DCHECK(state_ == PlanActivationState::kDelayOTASP);
StartOTASP();
}
void MobileActivator::StartOTASP() {
const NetworkState* network = GetNetworkState(service_path_);
if (!network) {
LOG(WARNING) << "Cellular service can't be found: " << service_path_;
return;
}
ChangeState(network, PlanActivationState::kStartOTASP,
ActivationError::kNone);
EvaluateCellularNetwork(network);
}
void MobileActivator::HandleOTASPTimeout() {
LOG(WARNING) << "OTASP seems to be taking too long.";
const NetworkState* network = GetNetworkState(service_path_);
if (!network) {
LOG(WARNING) << "Cellular service can't be found: " << service_path_;
return;
}
// We're here because one of OTASP steps is taking too long to complete.
// Usually, this means something bad has happened below us.
if (state_ == PlanActivationState::kInitiatingActivation) {
++initial_OTASP_attempts_;
if (initial_OTASP_attempts_ <= kMaxOTASPTries) {
ChangeState(network, PlanActivationState::kReconnecting,
ActivationError::kActivationFailed);
return;
}
} else if (state_ == PlanActivationState::kTryingOTASP) {
++trying_OTASP_attempts_;
if (trying_OTASP_attempts_ <= kMaxOTASPTries) {
ChangeState(network, PlanActivationState::kReconnecting,
ActivationError::kActivationFailed);
return;
}
} else if (state_ == PlanActivationState::kOTASP) {
++final_OTASP_attempts_;
if (final_OTASP_attempts_ <= kMaxOTASPTries) {
// Give the portal time to propagate all those magic bits.
ChangeState(network, PlanActivationState::kDelayOTASP,
ActivationError::kActivationFailed);
return;
}
} else {
LOG(ERROR) << "OTASP timed out from a non-OTASP wait state?";
}
LOG(ERROR) << "OTASP failed too many times; aborting.";
ChangeState(network, PlanActivationState::kError,
ActivationError::kActivationFailed);
}
void MobileActivator::ConnectNetwork(const NetworkState* network) {
NetworkHandler::Get()->network_connection_handler()->ConnectToNetwork(
network->path(), base::DoNothing(), network_handler::ErrorCallback(),
false /* check_error_state */, ConnectCallbackMode::ON_STARTED);
}
void MobileActivator::ForceReconnect(const NetworkState* network,
PlanActivationState next_state) {
DCHECK(network);
// Store away our next destination for when we complete.
post_reconnect_state_ = next_state;
UMA_HISTOGRAM_COUNTS_1M("Cellular.ActivationRetry", 1);
// First, disconnect...
VLOG(1) << "Disconnecting from " << network->path();
// Explicit service Disconnect()s disable autoconnect on the service until
// Connect() is called on the service again. Hence this dance to explicitly
// call Connect().
NetworkHandler::Get()->network_connection_handler()->DisconnectNetwork(
network->path(), base::DoNothing(), network_handler::ErrorCallback());
// Keep trying to connect until told otherwise.
continue_reconnect_timer_.Stop();
continue_reconnect_timer_.Start(FROM_HERE,
base::Milliseconds(kReconnectDelayMS), this,
&MobileActivator::ContinueConnecting);
// If we don't ever connect again, we're going to call this a failure.
reconnect_timeout_timer_.Stop();
reconnect_timeout_timer_.Start(FROM_HERE,
base::Milliseconds(kMaxReconnectTime), this,
&MobileActivator::ReconnectTimedOut);
}
void MobileActivator::ReconnectTimedOut() {
LOG(ERROR) << "Ending activation attempt after failing to reconnect.";
const NetworkState* network = GetNetworkState(service_path_);
if (!network) {
LOG(WARNING) << "Cellular service can't be found: " << service_path_;
return;
}
ChangeState(network, PlanActivationState::kError,
ActivationError::kActivationFailed);
}
void MobileActivator::ContinueConnecting() {
const NetworkState* network = GetNetworkState(service_path_);
if (network && network->IsConnectedState()) {
if (NetworkState::StateIsPortalled(network->connection_state()) &&
network->GetError() == shill::kErrorDNSLookupFailed) {
// It isn't an error to be in a restricted pool, but if DNS doesn't work,
// then we're not getting traffic through at all. Just disconnect and
// try again.
NetworkHandler::Get()->network_connection_handler()->DisconnectNetwork(
network->path(), base::DoNothing(), network_handler::ErrorCallback());
return;
}
// Stop this callback
continue_reconnect_timer_.Stop();
EvaluateCellularNetwork(network);
} else {
LOG(WARNING) << "Connect failed, will try again in a little bit.";
if (network) {
VLOG(1) << "Connecting to: " << network->path();
NetworkConnect::Get()->ConnectToNetworkId(network->guid());
}
}
}
void MobileActivator::RefreshCellularNetworks() {
if (state_ == PlanActivationState::kPageLoading ||
state_ == PlanActivationState::kDone ||
state_ == PlanActivationState::kError) {
return;
}
const NetworkState* network = GetNetworkState(service_path_);
if (!network) {
LOG(WARNING) << "Cellular service can't be found: " << service_path_;
return;
}
if (IsSimpleActivationFlow(network)) {
bool waiting = (state_ == PlanActivationState::kWaitingForConnection);
// We're only interested in whether or not we have access to the payment
// portal (regardless of which network we use to access it), so check
// the default network connection state. The default network is the network
// used to route default traffic. Also, note that we can access the
// payment portal over a cellular network in the portalled state.
const NetworkState* default_network = GetDefaultNetwork();
bool is_online_or_portal =
default_network &&
(default_network->connection_state() == shill::kStateOnline ||
(default_network->type() == shill::kTypeCellular &&
NetworkState::StateIsPortalled(default_network->connection_state())));
if (waiting && is_online_or_portal) {
ChangeState(network, post_reconnect_state_, ActivationError::kNone);
} else if (!waiting && !is_online_or_portal) {
ChangeState(network, PlanActivationState::kWaitingForConnection,
ActivationError::kNone);
}
}
EvaluateCellularNetwork(network);
}
const NetworkState* MobileActivator::GetNetworkState(
const std::string& service_path) {
return NetworkHandler::Get()->network_state_handler()->GetNetworkState(
service_path);
}
const NetworkState* MobileActivator::GetDefaultNetwork() {
return NetworkHandler::Get()->network_state_handler()->DefaultNetwork();
}
void MobileActivator::EvaluateCellularNetwork(const NetworkState* network) {
if (terminated_) {
LOG(ERROR) << "Tried to run MobileActivator state machine while "
<< "terminated.";
return;
}
if (!network) {
LOG(WARNING) << "Cellular service lost";
return;
}
LOG(WARNING) << "Cellular:\n service state=" << network->connection_state()
<< "\n ui=" << GetStateDescription(state_)
<< "\n activation=" << network->activation_state()
<< "\n error=" << network->GetError()
<< "\n setvice_path=" << network->path()
<< "\n connected=" << network->IsConnectedState();
// If the network is activated over non cellular network or OTA, the
// activator state does not depend on the network's own state.
if (IsSimpleActivationFlow(network))
return;
PlanActivationState new_state = PickNextState(network);
ActivationError error = new_state == PlanActivationState::kError
? ActivationError::kActivationFailed
: ActivationError::kNone;
ChangeState(network, new_state, error);
}
MobileActivator::PlanActivationState MobileActivator::PickNextState(
const NetworkState* network) const {
if (!network->IsConnectedState())
return PickNextOfflineState(network);
else
return PickNextOnlineState(network);
}
MobileActivator::PlanActivationState MobileActivator::PickNextOfflineState(
const NetworkState* network) const {
PlanActivationState new_state = state_;
const std::string& activation = network->activation_state();
switch (state_) {
case PlanActivationState::kPaymentPortalLoading:
case PlanActivationState::kShowingPayment:
if (!IsSimpleActivationFlow(network))
new_state = PlanActivationState::kReconnecting;
break;
case PlanActivationState::kStart:
if (activation == shill::kActivationStateActivated) {
if (NetworkState::StateIsPortalled(network->connection_state()))
new_state = PlanActivationState::kPaymentPortalLoading;
else
new_state = PlanActivationState::kDone;
} else if (activation == shill::kActivationStatePartiallyActivated) {
new_state = PlanActivationState::kTryingOTASP;
} else {
new_state = PlanActivationState::kInitiatingActivation;
}
break;
default:
VLOG(1) << "Waiting for cellular service to connect.";
break;
}
return new_state;
}
MobileActivator::PlanActivationState MobileActivator::PickNextOnlineState(
const NetworkState* network) const {
PlanActivationState new_state = state_;
const std::string& activation = network->activation_state();
switch (state_) {
case PlanActivationState::kStart:
if (activation == shill::kActivationStateActivated) {
if (network->connection_state() == shill::kStateOnline)
new_state = PlanActivationState::kDone;
else
new_state = PlanActivationState::kPaymentPortalLoading;
} else if (activation == shill::kActivationStatePartiallyActivated) {
new_state = PlanActivationState::kTryingOTASP;
} else {
new_state = PlanActivationState::kInitiatingActivation;
}
break;
case PlanActivationState::kStartOTASP: {
if (activation == shill::kActivationStatePartiallyActivated) {
new_state = PlanActivationState::kOTASP;
} else if (activation == shill::kActivationStateActivated) {
new_state = PlanActivationState::kReconnecting;
} else {
LOG(WARNING) << "Unexpected activation state for device "
<< network->path();
}
break;
}
case PlanActivationState::kDelayOTASP:
// Just ignore any changes until the OTASP retry timer kicks in.
break;
case PlanActivationState::kInitiatingActivation: {
if (activation == shill::kActivationStateActivated ||
activation == shill::kActivationStatePartiallyActivated) {
new_state = PlanActivationState::kStart;
} else if (activation == shill::kActivationStateNotActivated ||
activation == shill::kActivationStateActivating) {
// Wait in this state until activation state changes.
} else {
LOG(WARNING) << "Unknown transition";
}
break;
}
case PlanActivationState::kOTASP:
case PlanActivationState::kTryingOTASP:
if (activation == shill::kActivationStateNotActivated ||
activation == shill::kActivationStateActivating) {
VLOG(1) << "Waiting for the OTASP to finish and the service to "
<< "come back online";
} else if (activation == shill::kActivationStateActivated) {
new_state = PlanActivationState::kDone;
} else {
new_state = PlanActivationState::kPaymentPortalLoading;
}
break;
case PlanActivationState::kReconnectingPayment:
if (!NetworkState::StateIsPortalled(network->connection_state()) &&
activation == shill::kActivationStateActivated)
// We're not portalled, and we're already activated, so we're online!
new_state = PlanActivationState::kDone;
else
new_state = PlanActivationState::kPaymentPortalLoading;
break;
// Initial state
case PlanActivationState::kPageLoading:
break;
// Just ignore all signals until the site confirms payment.
case PlanActivationState::kPaymentPortalLoading:
case PlanActivationState::kShowingPayment:
case PlanActivationState::kWaitingForConnection:
break;
// Go where we decided earlier.
case PlanActivationState::kReconnecting:
new_state = post_reconnect_state_;
break;
// Activation completed/failed, ignore network changes.
case PlanActivationState::kDone:
case PlanActivationState::kError:
break;
}
return new_state;
}
// Debugging helper function, will take it out at the end.
const char* MobileActivator::GetStateDescription(PlanActivationState state) {
switch (state) {
case PlanActivationState::kPageLoading:
return "PAGE_LOADING";
case PlanActivationState::kStart:
return "ACTIVATION_START";
case PlanActivationState::kInitiatingActivation:
return "INITIATING_ACTIVATION";
case PlanActivationState::kTryingOTASP:
return "TRYING_OTASP";
case PlanActivationState::kPaymentPortalLoading:
return "PAYMENT_PORTAL_LOADING";
case PlanActivationState::kShowingPayment:
return "SHOWING_PAYMENT";
case PlanActivationState::kReconnectingPayment:
return "RECONNECTING_PAYMENT";
case PlanActivationState::kDelayOTASP:
return "DELAY_OTASP";
case PlanActivationState::kStartOTASP:
return "START_OTASP";
case PlanActivationState::kOTASP:
return "OTASP";
case PlanActivationState::kDone:
return "DONE";
case PlanActivationState::kError:
return "ERROR";
case PlanActivationState::kReconnecting:
return "RECONNECTING";
case PlanActivationState::kWaitingForConnection:
return "WAITING FOR CONNECTION";
}
return "UNKNOWN";
}
void MobileActivator::CompleteActivation() {
// Remove observers, we are done with this page.
network_state_handler_observer_.Reset();
}
bool MobileActivator::RunningActivation() const {
return !(state_ == PlanActivationState::kDone ||
state_ == PlanActivationState::kError ||
state_ == PlanActivationState::kPageLoading);
}
void MobileActivator::ChangeState(const NetworkState* network,
PlanActivationState new_state,
ActivationError error) {
// Report an error, by transitioning into a kError state with
// a "no service" error instead, if no network state is available (e.g. the
// cellular service no longer exists) when we are transitioning into certain
// plan activation state.
if (!network) {
switch (new_state) {
case PlanActivationState::kInitiatingActivation:
case PlanActivationState::kTryingOTASP:
case PlanActivationState::kOTASP:
case PlanActivationState::kDone:
new_state = PlanActivationState::kError;
error = ActivationError::kNoCellularService;
break;
default:
break;
}
}
static bool first_time = true;
VLOG(1) << "Activation state flip old = " << GetStateDescription(state_)
<< ", new = " << GetStateDescription(new_state);
if (state_ == new_state && !first_time)
return;
first_time = false;
VLOG(1) << "Transitioning...";
// Kill all the possible timers and callbacks we might have outstanding.
state_duration_timer_.Stop();
continue_reconnect_timer_.Stop();
reconnect_timeout_timer_.Stop();
const PlanActivationState old_state = state_;
state_ = new_state;
// Signal to observers layer that the state is changing.
for (auto& observer : observers_)
observer.OnActivationStateChanged(network, state_, error);
// Pick action that should happen on entering the new state.
switch (new_state) {
case PlanActivationState::kStart:
break;
case PlanActivationState::kDelayOTASP: {
UMA_HISTOGRAM_COUNTS_1M("Cellular.RetryOTASP", 1);
content::GetUIThreadTaskRunner({})->PostDelayedTask(
FROM_HERE,
base::BindOnce(&MobileActivator::RetryOTASP,
weak_ptr_factory_.GetWeakPtr()),
base::Milliseconds(kOTASPRetryDelay));
break;
}
case PlanActivationState::kStartOTASP:
break;
case PlanActivationState::kInitiatingActivation:
case PlanActivationState::kTryingOTASP:
case PlanActivationState::kOTASP:
// Starts the timer waiting for activation state changes.
// https://crbug.com/1021688.
StartOTASPTimer();
break;
case PlanActivationState::kPageLoading:
return;
case PlanActivationState::kPaymentPortalLoading:
case PlanActivationState::kShowingPayment:
case PlanActivationState::kReconnectingPayment:
// Fix for fix SSL for the walled gardens where cert chain verification
// might not work.
break;
case PlanActivationState::kWaitingForConnection:
post_reconnect_state_ = old_state;
break;
case PlanActivationState::kReconnecting: {
PlanActivationState next_state = old_state;
// Pick where we want to return to after we reconnect.
switch (old_state) {
case PlanActivationState::kPaymentPortalLoading:
case PlanActivationState::kShowingPayment:
// We decide here what to do next based on the state of the modem.
next_state = PlanActivationState::kReconnectingPayment;
break;
case PlanActivationState::kInitiatingActivation:
case PlanActivationState::kTryingOTASP:
next_state = PlanActivationState::kStart;
break;
case PlanActivationState::kStartOTASP:
case PlanActivationState::kOTASP:
if (!network || !network->IsConnectedState()) {
next_state = PlanActivationState::kStartOTASP;
} else {
// We're online, which means we've conspired with
// PickNextOnlineState to reconnect after activation (that's the
// only way we see this transition). Thus, after we reconnect, we
// should be done.
next_state = PlanActivationState::kDone;
}
break;
default:
LOG(ERROR) << "Transitioned to RECONNECTING from an unexpected "
<< "state.";
break;
}
if (network)
ForceReconnect(network, next_state);
break;
}
case PlanActivationState::kDone:
DCHECK(network);
CompleteActivation();
break;
case PlanActivationState::kError:
CompleteActivation();
UMA_HISTOGRAM_COUNTS_1M("Cellular.PlanFailed", 1);
break;
default:
break;
}
}
void MobileActivator::SignalCellularPlanPayment() {
DCHECK(!HasRecentCellularPlanPayment());
cellular_plan_payment_time_ = base::Time::Now();
}
bool MobileActivator::HasRecentCellularPlanPayment() const {
const int kRecentPlanPaymentHours = 6;
return (base::Time::Now() - cellular_plan_payment_time_).InHours() <
kRecentPlanPaymentHours;
}
} // namespace ash
Codebase Browser
chromium