src/service_manager_impl.cc - chromiumos/platform/cashew - Git at Google

 // Copyright (c) 2010, 2011 The Chromium OS Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "src/service_manager_impl.h"

 #include <glog/logging.h>

 #include "src/cashew_server.h"
 #include "src/service.h"

 namespace cashew {

 // Flimflam D-Bus indentifiers
 static const char *kFlimflamManagerName = "org.chromium.flimflam";
 static const char *kFlimflamManagerPath = "/";

 // Flimflam property names
 static const char *kDefaultTechnologyProperty = "DefaultTechnology";
 static const char *kServicesProperty = "Services";
 static const char *kStateProperty = "State";

 // Flimflam on-the-wire State values
 static const char *kFlimflamStateOffline = "offline";
 static const char *kFlimflamStateConnected = "connected";
 static const char *kFlimflamStateOnline = "online";

 // Flimflam service types
 static const char *kTypeCellular = "cellular";

 // GetFlimflamProperties retry interval
 static const guint kSecondsPerMinute = 60;
 static const guint kGetFlimflamPropertiesIntervalSeconds =
     1 * kSecondsPerMinute;

 ServiceManagerImpl::ServiceManagerImpl(DBus::Connection& connection,  // NOLINT
                                        GMainLoop * const main_loop)
     : DBus::ObjectProxy(connection, kFlimflamManagerPath,
                         kFlimflamManagerName),
       connection_(connection), main_loop_(CHECK_NOTNULL(main_loop)),
       cashew_server_(NULL), default_technology_(Service::kTypeUnknown),
       default_cellular_service_(NULL),
       connectivity_state_(kConnectivityStateUnknown),
       get_properties_source_id_(0), retrying_get_properties_(false) {
   // schedule a GetProperties() call to Flimflam to init our state
   // we'll keep trying periodically until we succeed
   // we'll subsequently update this state by monitoring PropertyChanged signals
   get_properties_source_id_ =
       g_idle_add(StaticGetFlimflamPropertiesCallback, this);
   if (get_properties_source_id_ == 0) {
     LOG(ERROR) << "ctor: g_idle_add failed";
   }
   property_changed_handler_.delegate(this);
 }

 ServiceManagerImpl::~ServiceManagerImpl() {
   DCHECK(!g_main_loop_is_running(main_loop_));
   ClearDefaultCellularService();
   DeleteServices(&services_);
   if (get_properties_source_id_ != 0 &&
       !g_source_remove(get_properties_source_id_)) {
     DLOG(WARNING) << "dtor: g_source_remove failed";
   }
 }

 const Service* ServiceManagerImpl::GetService(const std::string& service_path)
     const {
   ServiceMap::const_iterator it = services_.find(service_path);
   if (it == services_.end()) {
     return NULL;
   }
   DCHECK(it->second != NULL);
   return static_cast<const Service *>(it->second);
 }

 void ServiceManagerImpl::SetCashewServer(CashewServer *cashew_server) {
   DLOG(INFO) << "SetCashewServer";
   cashew_server_ = cashew_server;
 }

 Service::Type ServiceManagerImpl::GetDefaultTechnology() const {
   return default_technology_;
 }

 ServiceManager::ConnectivityState ServiceManagerImpl::GetConnectivityState()
     const {
   return connectivity_state_;
 }

 // static
 bool ServiceManagerImpl::IsOfflineConnectivityState(
     ServiceManager::ConnectivityState state) {
   if (state == kConnectivityStateUnknown ||
       state == kConnectivityStateOffline) {
     return true;
   }
   return false;
 }

 // static
 bool ServiceManagerImpl::IsOnlineConnectivityState(
     ServiceManager::ConnectivityState state) {
   if (state == kConnectivityStateConnected ||
       state == kConnectivityStateOnline) {
     return true;
   }
   return false;
 }

 // Flimflam Manager D-Bus Proxy methods

 void ServiceManagerImpl::PropertyChanged(const std::string& property_name,
                                          const DBus::Variant& new_value) {
   DLOG(INFO) << "PropertyChanged: property_name = " << property_name;
   // Queue a tuple representing this signal for later processing from the glib
   // main loop.  We do this to avoid libdbus-c++ deadlocks that can occur when
   // sending a dbus message from within a dbus callback like this one.
   PropertyChangedSignal signal(property_name, new_value);
   property_changed_handler_.EnqueueSignal(signal);
 }

 void ServiceManagerImpl::StateChanged(const std::string& new_state_string) {
   DLOG(INFO) << "StateChanged: new_state_string = " << new_state_string;
   // Queue a tuple representing this signal for later processing from the glib
   // main loop. See comments in PropertyChanged above.
   DBus::Variant new_value;
   new_value.writer().append_string(new_state_string.c_str());
   // StateChanged is a special case of PropertyChanged, so we just construct a
   // PropertyChanged signal containing the new state info
   PropertyChangedSignal signal(kStateProperty, new_value);
   property_changed_handler_.EnqueueSignal(signal);
 }

 // PropertyChangedDelegate methods

 void ServiceManagerImpl::OnPropertyChanged(
                                           const PropertyChangedHandler *handler,
                                           const std::string& property_name,
                                           const DBus::Variant& new_value) {
   DCHECK(handler == &property_changed_handler_);
   DLOG(INFO) << "OnPropertyChanged: property_name = " << property_name;
   if (property_name == kDefaultTechnologyProperty) {
     OnDefaultTechnologyUpdate(new_value.reader().get_string());
   } else if (property_name == kServicesProperty) {
     // interpret new_value as a vector of service paths
     ServicePathList paths;
     DBus::MessageIter reader = new_value.reader();
     reader >> paths;
     OnServicesUpdate(paths);
   } else if (property_name == kStateProperty) {
     OnStateUpdate(new_value.reader().get_string());
   } else {
     // we don't care about this property
   }
 }

 // Service methods

 void ServiceManagerImpl::EmitDataPlansUpdate(const Service& service) {
   DLOG(INFO) << "EmitDataPlansUpdate: service = " << service.GetPath();
   if (cashew_server_ == NULL) {
     DLOG(WARNING) << "EmitDataPlansUpdate: no Cashew server";
     return;
   }
   cashew_server_->EmitDataPlansUpdate(service);
 }

 void ServiceManagerImpl::OnDataPlanInactive(const Service& service,
                                             const DataPlan& plan) {
   DLOG(INFO) << "OnDataPlanInactive: service = " << service.GetPath()
       << ", plan = " << plan.GetName();
   DCHECK(!plan.IsActive());
   // TODO(vlaviano): hook for future use
   // we could emit a PlanExpired D-Bus signal for Chrome to consume
 }

 // Private methods

 void ServiceManagerImpl::DeleteServices(ServiceMap *service_map) {
   DCHECK(service_map != NULL);
   while (!service_map->empty()) {
     const std::string& path =
         static_cast<std::string>(service_map->begin()->first);
     DLOG(INFO) << "DeleteServices: deleting service: " << path;
     Service *service = static_cast<Service *>(service_map->begin()->second);
     DCHECK(service != NULL);
     DCHECK(service != default_cellular_service_);
     DCHECK(*service_map == services_ || GetService(service->GetPath()) == NULL);
     delete service;
     service_map->erase(service_map->begin());
   }
 }

 // static
 gboolean ServiceManagerImpl::StaticGetFlimflamPropertiesCallback(
                                                                 gpointer data) {
   ServiceManagerImpl *service_manager =
       reinterpret_cast<ServiceManagerImpl*>(data);
   CHECK_NOTNULL(service_manager);
   DCHECK_NE(service_manager->get_properties_source_id_, 0);
   if (!service_manager->GetFlimflamProperties()) {
     // call failed, so try again later
     DLOG(WARNING) << "StaticGetFlimflamPropertiesCallback: "
         << "GetFlimflamProperties failed, will retry in "
         << kGetFlimflamPropertiesIntervalSeconds << " secs";
     // if we've arrived here from our first g_idle_add call, set up a timer
     if (!service_manager->retrying_get_properties_) {
       guint source_id =
           g_timeout_add_seconds(kGetFlimflamPropertiesIntervalSeconds,
                                 StaticGetFlimflamPropertiesCallback,
                                 service_manager);
       service_manager->get_properties_source_id_ = source_id;
       if (source_id == 0) {
         LOG(ERROR) << "StaticGetFlimflamPropertiesCallback: "
             << "g_timeout_add_seconds failed";
         return FALSE;  // get rid of old glib source and give up
       }
       service_manager->retrying_get_properties_ = true;
       // get rid of our old glib source, but our new timer will call us
       return FALSE;
     }
     // otherwise, our timer is already set up
     // return TRUE to indicate that we want to be called again later
     return TRUE;
   }
   service_manager->get_properties_source_id_ = 0;
   service_manager->retrying_get_properties_ = false;
   return FALSE;  // we succeeded, so don't repeat
 }

 bool ServiceManagerImpl::GetFlimflamProperties() {
   DLOG(INFO) << "GetFlimflamProperties";
   PropertyMap properties;
   // dbus-c++ throws exceptions
   // invoke the "Existing Non-conformant Code" clause of the style guide and
   // isolate the rest of the system from this
   try {
     // TODO(vlaviano): make this call asynchronous
     properties = GetProperties();
   } catch (DBus::Error& error) {  // NOLINT
     LOG(WARNING) << "GetFlimflamProperties: GetProperties() -> Exception: "
         << error.name() << ": " << error.message();
     return false;
   } catch (...) {  // NOLINT
     LOG(WARNING) << "GetFlimflamProperties: GetProperties() -> Exception";
     return false;
   }
   DLOG(INFO) << "GetFlimflamProperties: Received " << properties.size()
       << " properties";

   // grab the properties in which we're interested
   PropertyMap::const_iterator it = properties.find(kDefaultTechnologyProperty);
   if (it != properties.end()) {
     const DBus::Variant& value = static_cast<DBus::Variant>(it->second);
     OnDefaultTechnologyUpdate(value.reader().get_string());
   } else {
     DLOG(WARNING) << "GetFlimflamProperties: no DefaultTechnology property";
   }
   it = properties.find(kServicesProperty);
   if (it != properties.end()) {
     const DBus::Variant& value = static_cast<DBus::Variant>(it->second);
     // interpret value as vector of service paths
     ServicePathList paths;
     DBus::MessageIter reader = value.reader();
     reader >> paths;
     OnServicesUpdate(paths);
   } else {
     DLOG(WARNING) << "GetFlimflamProperties: no Services property";
   }
   it = properties.find(kStateProperty);
   if (it != properties.end()) {
     const DBus::Variant& value = static_cast<DBus::Variant>(it->second);
     StateChanged(value.reader().get_string());
   } else {
     DLOG(WARNING) << "GetFlimflamProperties: no State property";
   }
   return true;
 }

 void ServiceManagerImpl::OnStateUpdate(const std::string& new_state_string) {
   DLOG(INFO) << "OnStateUpdate: new_state = " << new_state_string;
   ConnectivityState old_state = connectivity_state_;
   connectivity_state_ = ConnectivityStateFromString(new_state_string);
   // see if we're coming online or going offline
   // NOTE: we consider "unknown" to be offline
   if (IsOfflineConnectivityState(old_state) &&
       IsOnlineConnectivityState(connectivity_state_)) {
     OnFlimflamOnline();
   } else if (IsOnlineConnectivityState(old_state) &&
       IsOfflineConnectivityState(connectivity_state_)) {
     OnFlimflamOffline();
   }
 }

 void ServiceManagerImpl::OnDefaultTechnologyUpdate(
     const std::string& default_technology) {
   DLOG(INFO) << "OnDefaultTechnologyUpdate: default technology = "
       << default_technology;
   default_technology_ = Service::TypeFromString(default_technology);
   if (default_technology_ == Service::kTypeUnknown) {
     LOG(WARNING) << "OnDefaultTechnologyUpdate: unknown default technology: "
         << default_technology;
   }
   if (default_technology_ != Service::kTypeCellular &&
       default_cellular_service_ != NULL) {
     // if the default technology isn't cellular and yet we think that one of
     // our cellular services is the default service, then we need to update
     // our view of the world.
     ClearDefaultCellularService();
   }
 }

 void ServiceManagerImpl::OnServicesUpdate(const ServicePathList& paths) {
   // Remember old set of services. This is the baseline from which we will
   // determine what has changed.
   ServiceMap old_services = services_;
   services_.clear();

   // Flimflam service types are embedded in their path names, so we can use
   // the pattern "/cellular_" to decide which paths are cellular services.
   static const std::string cellular_pattern = std::string("/") + kTypeCellular
       + "_";

   // Walk paths in this update and see if they're new to us
   DLOG(INFO) << "OnServicesUpdate: " << paths.size() << " service paths";
   ServicePathList::const_iterator it;
   for (it = paths.begin(); it != paths.end(); ++it) {
     const DBus::Path& path = *it;

     // We only care about cellular services
     if (path.find(cellular_pattern) == std::string::npos) {
       continue;
     }

     ServiceMap::iterator old_it = old_services.find(path);
     if (old_it != old_services.end()) {
       // service is old: move it from old_services to services_
       Service *service = static_cast<Service *>(old_it->second);
       DCHECK(service != NULL);
       old_services.erase(old_it);
       services_[path] = service;
     } else {
       // service is new: create a Service obj for it and add it to services_
       OnNewService(path);
     }
   }

   // clear default service if it failed to appear in the update and we're
   // about to delete it
   if (default_cellular_service_ != NULL) {
     ServiceMap::const_iterator it =
         old_services.find(default_cellular_service_->GetPath());
     if (it != old_services.end()) {
       ClearDefaultCellularService();
     }
   }

   // services left in old_services failed to appear in the update: delete them
   DeleteServices(&old_services);

   // Flimflam always places the default service first in its list of services,
   // so we'll take a look at the first element in the paths list and see if the
   // default service has changed. Note that |paths| can be empty. We still want
   // to know about this, since it means that there is no default service.
   const DBus::Path *default_service_path = NULL;
   if (!paths.empty()) {
     default_service_path = &*paths.begin();
   }
   OnDefaultServiceUpdate(default_service_path);
 }

 void ServiceManagerImpl::OnNewService(const DBus::Path& path) {
   DLOG(INFO) << "OnNewService: " << path;
   DCHECK(GetService(path) == NULL);
   Service *service = Service::NewService(this, connection_, path);
   if (service == NULL) {
     LOG(ERROR) << "OnNewService: couldn't create service for " << path;
     return;
   }
   services_[path] = service;
 }

 void ServiceManagerImpl::OnDefaultServiceUpdate(const DBus::Path *path) {
   DLOG(INFO) << "OnDefaultServiceUpdate: new default service = "
       << ((path == NULL) ? "None" : *path);
   // check if new default service path (if any) corresponds to one of our
   // cellular services
   Service *new_default_cellular_service = NULL;
   if (path != NULL) {
     new_default_cellular_service = const_cast<Service*>(GetService(*path));
   }
   if (new_default_cellular_service != NULL) {
     SetDefaultCellularService(new_default_cellular_service);
   } else {
     ClearDefaultCellularService();
   }
 }

 void ServiceManagerImpl::ClearDefaultCellularService() {
   DLOG(INFO) << "ClearDefaultCellularService";
   if (default_cellular_service_ != NULL) {
     DCHECK(default_cellular_service_->IsDefaultService());
     default_cellular_service_->OnDefaultServiceUpdate(false);
     default_cellular_service_ = NULL;
   }
 }

 void ServiceManagerImpl::SetDefaultCellularService(Service *service) {
   DLOG(INFO) << "SetDefaultCellularService: "
       << ((service == NULL) ? "None" : service->GetPath());
   if (default_cellular_service_ == service) {
     return;
   }
   if (default_cellular_service_ != NULL) {
     ClearDefaultCellularService();
   }
   DCHECK(default_cellular_service_ == NULL);
   if (service != NULL) {
     DCHECK(!service->IsDefaultService());
     service->OnDefaultServiceUpdate(true);
     default_cellular_service_ = service;
   }
 }

 // static
 ServiceManager::ConnectivityState
 ServiceManagerImpl::ConnectivityStateFromString(const std::string& state) {
   if (state == kFlimflamStateOffline) {
     return kConnectivityStateOffline;
   }
   if (state == kFlimflamStateConnected) {
     return kConnectivityStateConnected;
   }
   if (state == kFlimflamStateOnline) {
     return kConnectivityStateOnline;
   }
   return kConnectivityStateUnknown;
 }

 void ServiceManagerImpl::OnFlimflamOnline() {
   DLOG(INFO) << "OnFlimflamOnline";
   // notify our child services
   ServiceMap::iterator it;
   for (it = services_.begin(); it != services_.end(); ++it) {
     Service *service = static_cast<Service*>(it->second);
     DCHECK(service != NULL);
     service->OnFlimflamOnline();
   }
 }

 void ServiceManagerImpl::OnFlimflamOffline() {
   DLOG(INFO) << "OnFlimflamOffline";
   // notify our child services
   ServiceMap::iterator it;
   for (it = services_.begin(); it != services_.end(); ++it) {
     Service *service = static_cast<Service*>(it->second);
     DCHECK(service != NULL);
     service->OnFlimflamOffline();
   }
 }

 }  // namespace cashew
	// Copyright (c) 2010, 2011 The Chromium OS Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "src/service_manager_impl.h"

	#include <glog/logging.h>

	#include "src/cashew_server.h"
	#include "src/service.h"

	namespace cashew {

	// Flimflam D-Bus indentifiers
	static const char *kFlimflamManagerName = "org.chromium.flimflam";
	static const char *kFlimflamManagerPath = "/";

	// Flimflam property names
	static const char *kDefaultTechnologyProperty = "DefaultTechnology";
	static const char *kServicesProperty = "Services";
	static const char *kStateProperty = "State";

	// Flimflam on-the-wire State values
	static const char *kFlimflamStateOffline = "offline";
	static const char *kFlimflamStateConnected = "connected";
	static const char *kFlimflamStateOnline = "online";

	// Flimflam service types
	static const char *kTypeCellular = "cellular";

	// GetFlimflamProperties retry interval
	static const guint kSecondsPerMinute = 60;
	static const guint kGetFlimflamPropertiesIntervalSeconds =
	1 * kSecondsPerMinute;

	ServiceManagerImpl::ServiceManagerImpl(DBus::Connection& connection, // NOLINT
	GMainLoop * const main_loop)
	: DBus::ObjectProxy(connection, kFlimflamManagerPath,
	kFlimflamManagerName),
	connection_(connection), main_loop_(CHECK_NOTNULL(main_loop)),
	cashew_server_(NULL), default_technology_(Service::kTypeUnknown),
	default_cellular_service_(NULL),
	connectivity_state_(kConnectivityStateUnknown),
	get_properties_source_id_(0), retrying_get_properties_(false) {
	// schedule a GetProperties() call to Flimflam to init our state
	// we'll keep trying periodically until we succeed
	// we'll subsequently update this state by monitoring PropertyChanged signals
	get_properties_source_id_ =
	g_idle_add(StaticGetFlimflamPropertiesCallback, this);
	if (get_properties_source_id_ == 0) {
	LOG(ERROR) << "ctor: g_idle_add failed";
	}
	property_changed_handler_.delegate(this);
	}

	ServiceManagerImpl::~ServiceManagerImpl() {
	DCHECK(!g_main_loop_is_running(main_loop_));
	ClearDefaultCellularService();
	DeleteServices(&services_);
	if (get_properties_source_id_ != 0 &&
	!g_source_remove(get_properties_source_id_)) {
	DLOG(WARNING) << "dtor: g_source_remove failed";
	}
	}

	const Service* ServiceManagerImpl::GetService(const std::string& service_path)
	const {
	ServiceMap::const_iterator it = services_.find(service_path);
	if (it == services_.end()) {
	return NULL;
	}
	DCHECK(it->second != NULL);
	return static_cast<const Service *>(it->second);
	}

	void ServiceManagerImpl::SetCashewServer(CashewServer *cashew_server) {
	DLOG(INFO) << "SetCashewServer";
	cashew_server_ = cashew_server;
	}

	Service::Type ServiceManagerImpl::GetDefaultTechnology() const {
	return default_technology_;
	}

	ServiceManager::ConnectivityState ServiceManagerImpl::GetConnectivityState()
	const {
	return connectivity_state_;
	}

	// static
	bool ServiceManagerImpl::IsOfflineConnectivityState(
	ServiceManager::ConnectivityState state) {
	if (state == kConnectivityStateUnknown \|\|
	state == kConnectivityStateOffline) {
	return true;
	}
	return false;
	}

	// static
	bool ServiceManagerImpl::IsOnlineConnectivityState(
	ServiceManager::ConnectivityState state) {
	if (state == kConnectivityStateConnected \|\|
	state == kConnectivityStateOnline) {
	return true;
	}
	return false;
	}

	// Flimflam Manager D-Bus Proxy methods

	void ServiceManagerImpl::PropertyChanged(const std::string& property_name,
	const DBus::Variant& new_value) {
	DLOG(INFO) << "PropertyChanged: property_name = " << property_name;
	// Queue a tuple representing this signal for later processing from the glib
	// main loop. We do this to avoid libdbus-c++ deadlocks that can occur when
	// sending a dbus message from within a dbus callback like this one.
	PropertyChangedSignal signal(property_name, new_value);
	property_changed_handler_.EnqueueSignal(signal);
	}

	void ServiceManagerImpl::StateChanged(const std::string& new_state_string) {
	DLOG(INFO) << "StateChanged: new_state_string = " << new_state_string;
	// Queue a tuple representing this signal for later processing from the glib
	// main loop. See comments in PropertyChanged above.
	DBus::Variant new_value;
	new_value.writer().append_string(new_state_string.c_str());
	// StateChanged is a special case of PropertyChanged, so we just construct a
	// PropertyChanged signal containing the new state info
	PropertyChangedSignal signal(kStateProperty, new_value);
	property_changed_handler_.EnqueueSignal(signal);
	}

	// PropertyChangedDelegate methods

	void ServiceManagerImpl::OnPropertyChanged(
	const PropertyChangedHandler *handler,
	const std::string& property_name,
	const DBus::Variant& new_value) {
	DCHECK(handler == &property_changed_handler_);
	DLOG(INFO) << "OnPropertyChanged: property_name = " << property_name;
	if (property_name == kDefaultTechnologyProperty) {
	OnDefaultTechnologyUpdate(new_value.reader().get_string());
	} else if (property_name == kServicesProperty) {
	// interpret new_value as a vector of service paths
	ServicePathList paths;
	DBus::MessageIter reader = new_value.reader();
	reader >> paths;
	OnServicesUpdate(paths);
	} else if (property_name == kStateProperty) {
	OnStateUpdate(new_value.reader().get_string());
	} else {
	// we don't care about this property
	}
	}

	// Service methods

	void ServiceManagerImpl::EmitDataPlansUpdate(const Service& service) {
	DLOG(INFO) << "EmitDataPlansUpdate: service = " << service.GetPath();
	if (cashew_server_ == NULL) {
	DLOG(WARNING) << "EmitDataPlansUpdate: no Cashew server";
	return;
	}
	cashew_server_->EmitDataPlansUpdate(service);
	}

	void ServiceManagerImpl::OnDataPlanInactive(const Service& service,
	const DataPlan& plan) {
	DLOG(INFO) << "OnDataPlanInactive: service = " << service.GetPath()
	<< ", plan = " << plan.GetName();
	DCHECK(!plan.IsActive());
	// TODO(vlaviano): hook for future use
	// we could emit a PlanExpired D-Bus signal for Chrome to consume
	}

	// Private methods

	void ServiceManagerImpl::DeleteServices(ServiceMap *service_map) {
	DCHECK(service_map != NULL);
	while (!service_map->empty()) {
	const std::string& path =
	static_cast<std::string>(service_map->begin()->first);
	DLOG(INFO) << "DeleteServices: deleting service: " << path;
	Service service = static_cast<Service >(service_map->begin()->second);
	DCHECK(service != NULL);
	DCHECK(service != default_cellular_service_);
	DCHECK(*service_map == services_ \|\| GetService(service->GetPath()) == NULL);
	delete service;
	service_map->erase(service_map->begin());
	}
	}

	// static
	gboolean ServiceManagerImpl::StaticGetFlimflamPropertiesCallback(
	gpointer data) {
	ServiceManagerImpl *service_manager =
	reinterpret_cast<ServiceManagerImpl*>(data);
	CHECK_NOTNULL(service_manager);
	DCHECK_NE(service_manager->get_properties_source_id_, 0);
	if (!service_manager->GetFlimflamProperties()) {
	// call failed, so try again later
	DLOG(WARNING) << "StaticGetFlimflamPropertiesCallback: "
	<< "GetFlimflamProperties failed, will retry in "
	<< kGetFlimflamPropertiesIntervalSeconds << " secs";
	// if we've arrived here from our first g_idle_add call, set up a timer
	if (!service_manager->retrying_get_properties_) {
	guint source_id =
	g_timeout_add_seconds(kGetFlimflamPropertiesIntervalSeconds,
	StaticGetFlimflamPropertiesCallback,
	service_manager);
	service_manager->get_properties_source_id_ = source_id;
	if (source_id == 0) {
	LOG(ERROR) << "StaticGetFlimflamPropertiesCallback: "
	<< "g_timeout_add_seconds failed";
	return FALSE; // get rid of old glib source and give up
	}
	service_manager->retrying_get_properties_ = true;
	// get rid of our old glib source, but our new timer will call us
	return FALSE;
	}
	// otherwise, our timer is already set up
	// return TRUE to indicate that we want to be called again later
	return TRUE;
	}
	service_manager->get_properties_source_id_ = 0;
	service_manager->retrying_get_properties_ = false;
	return FALSE; // we succeeded, so don't repeat
	}

	bool ServiceManagerImpl::GetFlimflamProperties() {
	DLOG(INFO) << "GetFlimflamProperties";
	PropertyMap properties;
	// dbus-c++ throws exceptions
	// invoke the "Existing Non-conformant Code" clause of the style guide and
	// isolate the rest of the system from this
	try {
	// TODO(vlaviano): make this call asynchronous
	properties = GetProperties();
	} catch (DBus::Error& error) { // NOLINT
	LOG(WARNING) << "GetFlimflamProperties: GetProperties() -> Exception: "
	<< error.name() << ": " << error.message();
	return false;
	} catch (...) { // NOLINT
	LOG(WARNING) << "GetFlimflamProperties: GetProperties() -> Exception";
	return false;
	}
	DLOG(INFO) << "GetFlimflamProperties: Received " << properties.size()
	<< " properties";

	// grab the properties in which we're interested
	PropertyMap::const_iterator it = properties.find(kDefaultTechnologyProperty);
	if (it != properties.end()) {
	const DBus::Variant& value = static_cast<DBus::Variant>(it->second);
	OnDefaultTechnologyUpdate(value.reader().get_string());
	} else {
	DLOG(WARNING) << "GetFlimflamProperties: no DefaultTechnology property";
	}
	it = properties.find(kServicesProperty);
	if (it != properties.end()) {
	const DBus::Variant& value = static_cast<DBus::Variant>(it->second);
	// interpret value as vector of service paths
	ServicePathList paths;
	DBus::MessageIter reader = value.reader();
	reader >> paths;
	OnServicesUpdate(paths);
	} else {
	DLOG(WARNING) << "GetFlimflamProperties: no Services property";
	}
	it = properties.find(kStateProperty);
	if (it != properties.end()) {
	const DBus::Variant& value = static_cast<DBus::Variant>(it->second);
	StateChanged(value.reader().get_string());
	} else {
	DLOG(WARNING) << "GetFlimflamProperties: no State property";
	}
	return true;
	}

	void ServiceManagerImpl::OnStateUpdate(const std::string& new_state_string) {
	DLOG(INFO) << "OnStateUpdate: new_state = " << new_state_string;
	ConnectivityState old_state = connectivity_state_;
	connectivity_state_ = ConnectivityStateFromString(new_state_string);
	// see if we're coming online or going offline
	// NOTE: we consider "unknown" to be offline
	if (IsOfflineConnectivityState(old_state) &&
	IsOnlineConnectivityState(connectivity_state_)) {
	OnFlimflamOnline();
	} else if (IsOnlineConnectivityState(old_state) &&
	IsOfflineConnectivityState(connectivity_state_)) {
	OnFlimflamOffline();
	}
	}

	void ServiceManagerImpl::OnDefaultTechnologyUpdate(
	const std::string& default_technology) {
	DLOG(INFO) << "OnDefaultTechnologyUpdate: default technology = "
	<< default_technology;
	default_technology_ = Service::TypeFromString(default_technology);
	if (default_technology_ == Service::kTypeUnknown) {
	LOG(WARNING) << "OnDefaultTechnologyUpdate: unknown default technology: "
	<< default_technology;
	}
	if (default_technology_ != Service::kTypeCellular &&
	default_cellular_service_ != NULL) {
	// if the default technology isn't cellular and yet we think that one of
	// our cellular services is the default service, then we need to update
	// our view of the world.
	ClearDefaultCellularService();
	}
	}

	void ServiceManagerImpl::OnServicesUpdate(const ServicePathList& paths) {
	// Remember old set of services. This is the baseline from which we will
	// determine what has changed.
	ServiceMap old_services = services_;
	services_.clear();

	// Flimflam service types are embedded in their path names, so we can use
	// the pattern "/cellular_" to decide which paths are cellular services.
	static const std::string cellular_pattern = std::string("/") + kTypeCellular
	+ "_";

	// Walk paths in this update and see if they're new to us
	DLOG(INFO) << "OnServicesUpdate: " << paths.size() << " service paths";
	ServicePathList::const_iterator it;
	for (it = paths.begin(); it != paths.end(); ++it) {
	const DBus::Path& path = *it;

	// We only care about cellular services
	if (path.find(cellular_pattern) == std::string::npos) {
	continue;
	}

	ServiceMap::iterator old_it = old_services.find(path);
	if (old_it != old_services.end()) {
	// service is old: move it from old_services to services_
	Service service = static_cast<Service >(old_it->second);
	DCHECK(service != NULL);
	old_services.erase(old_it);
	services_[path] = service;
	} else {
	// service is new: create a Service obj for it and add it to services_
	OnNewService(path);
	}
	}

	// clear default service if it failed to appear in the update and we're
	// about to delete it
	if (default_cellular_service_ != NULL) {
	ServiceMap::const_iterator it =
	old_services.find(default_cellular_service_->GetPath());
	if (it != old_services.end()) {
	ClearDefaultCellularService();
	}
	}

	// services left in old_services failed to appear in the update: delete them
	DeleteServices(&old_services);

	// Flimflam always places the default service first in its list of services,
	// so we'll take a look at the first element in the paths list and see if the
	// default service has changed. Note that \|paths\| can be empty. We still want
	// to know about this, since it means that there is no default service.
	const DBus::Path *default_service_path = NULL;
	if (!paths.empty()) {
	default_service_path = &*paths.begin();
	}
	OnDefaultServiceUpdate(default_service_path);
	}

	void ServiceManagerImpl::OnNewService(const DBus::Path& path) {
	DLOG(INFO) << "OnNewService: " << path;
	DCHECK(GetService(path) == NULL);
	Service *service = Service::NewService(this, connection_, path);
	if (service == NULL) {
	LOG(ERROR) << "OnNewService: couldn't create service for " << path;
	return;
	}
	services_[path] = service;
	}

	void ServiceManagerImpl::OnDefaultServiceUpdate(const DBus::Path *path) {
	DLOG(INFO) << "OnDefaultServiceUpdate: new default service = "
	<< ((path == NULL) ? "None" : *path);
	// check if new default service path (if any) corresponds to one of our
	// cellular services
	Service *new_default_cellular_service = NULL;
	if (path != NULL) {
	new_default_cellular_service = const_cast<Service>(GetService(path));
	}
	if (new_default_cellular_service != NULL) {
	SetDefaultCellularService(new_default_cellular_service);
	} else {
	ClearDefaultCellularService();
	}
	}

	void ServiceManagerImpl::ClearDefaultCellularService() {
	DLOG(INFO) << "ClearDefaultCellularService";
	if (default_cellular_service_ != NULL) {
	DCHECK(default_cellular_service_->IsDefaultService());
	default_cellular_service_->OnDefaultServiceUpdate(false);
	default_cellular_service_ = NULL;
	}
	}

	void ServiceManagerImpl::SetDefaultCellularService(Service *service) {
	DLOG(INFO) << "SetDefaultCellularService: "
	<< ((service == NULL) ? "None" : service->GetPath());
	if (default_cellular_service_ == service) {
	return;
	}
	if (default_cellular_service_ != NULL) {
	ClearDefaultCellularService();
	}
	DCHECK(default_cellular_service_ == NULL);
	if (service != NULL) {
	DCHECK(!service->IsDefaultService());
	service->OnDefaultServiceUpdate(true);
	default_cellular_service_ = service;
	}
	}

	// static
	ServiceManager::ConnectivityState
	ServiceManagerImpl::ConnectivityStateFromString(const std::string& state) {
	if (state == kFlimflamStateOffline) {
	return kConnectivityStateOffline;
	}
	if (state == kFlimflamStateConnected) {
	return kConnectivityStateConnected;
	}
	if (state == kFlimflamStateOnline) {
	return kConnectivityStateOnline;
	}
	return kConnectivityStateUnknown;
	}

	void ServiceManagerImpl::OnFlimflamOnline() {
	DLOG(INFO) << "OnFlimflamOnline";
	// notify our child services
	ServiceMap::iterator it;
	for (it = services_.begin(); it != services_.end(); ++it) {
	Service service = static_cast<Service>(it->second);
	DCHECK(service != NULL);
	service->OnFlimflamOnline();
	}
	}

	void ServiceManagerImpl::OnFlimflamOffline() {
	DLOG(INFO) << "OnFlimflamOffline";
	// notify our child services
	ServiceMap::iterator it;
	for (it = services_.begin(); it != services_.end(); ++it) {
	Service service = static_cast<Service>(it->second);
	DCHECK(service != NULL);
	service->OnFlimflamOffline();
	}
	}

	} // namespace cashew