Home | History | Annotate | Download | only in network 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "chromeos/network/device_state.h"
      6 
      7 #include "base/logging.h"
      8 #include "base/metrics/histogram.h"
      9 #include "base/strings/stringprintf.h"
     10 #include "base/values.h"
     11 #include "third_party/cros_system_api/dbus/service_constants.h"
     12 
     13 namespace chromeos {
     14 
     15 DeviceState::DeviceState(const std::string& path)
     16     : ManagedState(MANAGED_TYPE_DEVICE, path),
     17       provider_requires_roaming_(false),
     18       support_network_scan_(false),
     19       scanning_(false),
     20       sim_lock_enabled_(false),
     21       sim_present_(true),
     22       eap_authentication_completed_(false) {
     23 }
     24 
     25 DeviceState::~DeviceState() {
     26 }
     27 
     28 bool DeviceState::PropertyChanged(const std::string& key,
     29                                   const base::Value& value) {
     30   // All property values get stored in |properties_|.
     31   properties_.SetWithoutPathExpansion(key, value.DeepCopy());
     32 
     33   if (ManagedStatePropertyChanged(key, value))
     34     return true;
     35   if (key == shill::kAddressProperty) {
     36     return GetStringValue(key, value, &mac_address_);
     37   } else if (key == shill::kScanningProperty) {
     38     return GetBooleanValue(key, value, &scanning_);
     39   } else if (key == shill::kSupportNetworkScanProperty) {
     40     return GetBooleanValue(key, value, &support_network_scan_);
     41   } else if (key == shill::kProviderRequiresRoamingProperty) {
     42     return GetBooleanValue(key, value, &provider_requires_roaming_);
     43   } else if (key == shill::kHomeProviderProperty) {
     44     const base::DictionaryValue* dict = NULL;
     45     if (!value.GetAsDictionary(&dict))
     46       return false;
     47     std::string home_provider_country;
     48     std::string home_provider_name;
     49     dict->GetStringWithoutPathExpansion(shill::kOperatorCountryKey,
     50                                         &home_provider_country);
     51     dict->GetStringWithoutPathExpansion(shill::kOperatorNameKey,
     52                                         &home_provider_name);
     53     // Set home_provider_id_
     54     if (!home_provider_name.empty() && !home_provider_country.empty()) {
     55       home_provider_id_ = base::StringPrintf(
     56           "%s (%s)",
     57           home_provider_name.c_str(),
     58           home_provider_country.c_str());
     59     } else {
     60       dict->GetStringWithoutPathExpansion(shill::kOperatorCodeKey,
     61                                           &home_provider_id_);
     62       LOG(WARNING) << "Carrier ID not defined, using code instead: "
     63                    << home_provider_id_;
     64     }
     65     return true;
     66   } else if (key == shill::kTechnologyFamilyProperty) {
     67     return GetStringValue(key, value, &technology_family_);
     68   } else if (key == shill::kCarrierProperty) {
     69     return GetStringValue(key, value, &carrier_);
     70   } else if (key == shill::kFoundNetworksProperty) {
     71     const base::ListValue* list = NULL;
     72     if (!value.GetAsList(&list))
     73       return false;
     74     CellularScanResults parsed_results;
     75     if (!network_util::ParseCellularScanResults(*list, &parsed_results))
     76       return false;
     77     scan_results_.swap(parsed_results);
     78     return true;
     79   } else if (key == shill::kSIMLockStatusProperty) {
     80     const base::DictionaryValue* dict = NULL;
     81     if (!value.GetAsDictionary(&dict))
     82       return false;
     83 
     84     // Return true if at least one of the property values changed.
     85     bool property_changed = false;
     86     const base::Value* out_value = NULL;
     87     if (!dict->GetWithoutPathExpansion(shill::kSIMLockRetriesLeftProperty,
     88                                        &out_value))
     89       return false;
     90     if (GetUInt32Value(shill::kSIMLockRetriesLeftProperty,
     91                        *out_value, &sim_retries_left_))
     92       property_changed = true;
     93 
     94     if (!dict->GetWithoutPathExpansion(shill::kSIMLockTypeProperty,
     95                                        &out_value))
     96       return false;
     97     if (GetStringValue(shill::kSIMLockTypeProperty,
     98                        *out_value, &sim_lock_type_))
     99       property_changed = true;
    100 
    101     if (!dict->GetWithoutPathExpansion(shill::kSIMLockEnabledProperty,
    102                                        &out_value))
    103       return false;
    104     if (GetBooleanValue(shill::kSIMLockEnabledProperty,
    105                         *out_value, &sim_lock_enabled_))
    106       property_changed = true;
    107 
    108     return property_changed;
    109   } else if (key == shill::kMeidProperty) {
    110     return GetStringValue(key, value, &meid_);
    111   } else if (key == shill::kImeiProperty) {
    112     return GetStringValue(key, value, &imei_);
    113   } else if (key == shill::kIccidProperty) {
    114     return GetStringValue(key, value, &iccid_);
    115   } else if (key == shill::kMdnProperty) {
    116     return GetStringValue(key, value, &mdn_);
    117   } else if (key == shill::kSIMPresentProperty) {
    118     return GetBooleanValue(key, value, &sim_present_);
    119   } else if (key == shill::kEapAuthenticationCompletedProperty) {
    120     return GetBooleanValue(key, value, &eap_authentication_completed_);
    121   }
    122   return false;
    123 }
    124 
    125 bool DeviceState::InitialPropertiesReceived(
    126     const base::DictionaryValue& properties) {
    127   // Update UMA stats.
    128   if (sim_present_) {
    129     bool locked = !sim_lock_type_.empty();
    130     UMA_HISTOGRAM_BOOLEAN("Cellular.SIMLocked", locked);
    131   }
    132   return false;
    133 }
    134 
    135 std::string DeviceState::GetFormattedMacAddress() const {
    136   if (mac_address_.size() % 2 != 0)
    137     return mac_address_;
    138   std::string result;
    139   for (size_t i = 0; i < mac_address_.size(); ++i) {
    140     if ((i != 0) && (i % 2 == 0))
    141       result.push_back(':');
    142     result.push_back(mac_address_[i]);
    143   }
    144   return result;
    145 }
    146 
    147 bool DeviceState::IsSimAbsent() const {
    148   return technology_family_ == shill::kTechnologyFamilyGsm && !sim_present_;
    149 }
    150 
    151 }  // namespace chromeos
    152