async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry):
"""Set up Google WiFi component from a config entry."""
polling_interval = entry.options.get(CONF_SCAN_INTERVAL, POLLING_INTERVAL)
conf = entry.data
conf_options = entry.options
session = aiohttp_client.async_get_clientsession(hass)
api = GoogleWifi(refresh_token=conf[REFRESH_TOKEN], session=session)
try:
await api.connect()
except ConnectionError as error:
_LOGGER.debug(f"Google WiFi API: {error}")
raise PlatformNotReady from error
except ValueError as error:
_LOGGER.debug(f"Google WiFi API: {error}")
raise ConfigEntryNotReady from error
coordinator = GoogleWiFiUpdater(
hass,
api=api,
name="GoogleWifi",
polling_interval=polling_interval,
refresh_token=conf[REFRESH_TOKEN],
entry=entry,
add_disabled=conf.get(ADD_DISABLED, True),
auto_speedtest=conf_options.get(CONF_SPEEDTEST, DEFAULT_SPEEDTEST),
speedtest_interval=conf_options.get(
CONF_SPEEDTEST_INTERVAL, DEFAULT_SPEEDTEST_INTERVAL
),
)
await coordinator.async_refresh()
if not coordinator.last_update_success:
raise ConfigEntryNotReady
hass.data[DOMAIN][entry.entry_id] = {
COORDINATOR: coordinator,
GOOGLEWIFI_API: api,
}
for component in PLATFORMS:
_LOGGER.info(f"Setting up platform: {component}")
hass.async_create_task(
hass.config_entries.async_forward_entry_setup(entry, component)
)
return True
async def _async_update_data(self):
"""Fetch data from Google Wifi API."""
try:
system_data = await self.api.get_systems()
except GoogleWifiException as error:
_LOGGER.info(f"Google Connection Error. Creating new session.")
session = aiohttp_client.async_create_clientsession(self.hass)
self.api = GoogleWifi(refresh_token=self.refresh_token, session=session)
raise PlatformNotReady from error
except ConnectionError as error:
_LOGGER.info(f"Google Wifi API: {error}")
raise PlatformNotReady from error
except ValueError as error:
_LOGGER.info(f"Google Wifi API: {error}")
raise ConfigEntryNotReady from error
return system_data
async def async_step_user(self, user_input=None):
"""Handle the initial step."""
errors = {}
config_entry = self.hass.config_entries.async_entries(DOMAIN)
if config_entry:
return self.async_abort(reason="single_instance_allowed")
if user_input is not None:
session = aiohttp_client.async_get_clientsession(self.hass)
token = user_input[REFRESH_TOKEN]
api_client = GoogleWifi(token, session)
try:
await api_client.connect()
except ValueError:
errors["base"] = "invalid_auth"
except ConnectionError:
errors["base"] = "cannot_connect"
except Exception: # pylint: disable=broad-except
_LOGGER.exception("Unexpected exception")
errors["base"] = "unknown"
else:
await self.async_set_unique_id(user_input[REFRESH_TOKEN])
self._abort_if_unique_id_configured()
return self.async_create_entry(title="Google Wifi",
data=user_input)
return self.async_show_form(
step_id="user",
data_schema=vol.Schema({
vol.Required(REFRESH_TOKEN):
str,
vol.Required(ADD_DISABLED, default=True):
bool,
}),
errors=errors,
)
async def _async_update_data(self):
"""Fetch data from Google Wifi API."""
try:
system_data = await self.api.get_systems()
for system_id, system in system_data.items():
connected_count = 0
guest_connected_count = 0
main_network = system["groupSettings"]["lanSettings"].get(
"dhcpPoolBegin", " " * 10
)
main_network = ".".join(main_network.split(".", 3)[:3])
for device_id, device in system["devices"].items():
device_network = device.get("ipAddress", " " * 10)
device_network = ".".join(device_network.split(".", 3)[:3])
if device_id not in self.devicelist:
to_add = {
"system_id": system_id,
"device_id": device_id,
"device": device,
}
async_dispatcher_send(self.hass, SIGNAL_ADD_DEVICE, to_add)
self.devicelist.append(device_id)
if device.get("connected") and main_network == device_network:
connected_count += 1
device["network"] = "main"
elif (
device.get("connected")
and device.get("unfilteredFriendlyType") != "Nest Wifi point"
):
guest_connected_count += 1
device["network"] = "guest"
elif device.get("unfilteredFriendlyType") == "Nest Wifi point":
connected_count += 1
device["network"] = "main"
for known_device in self.devicelist:
if known_device not in system["devices"]:
async_dispatcher_send(
self.hass, SIGNAL_DELETE_DEVICE, known_device
)
self.devicelist.remove(known_device)
system_data[system_id]["connected_devices"] = connected_count
system_data[system_id]["guest_devices"] = guest_connected_count
system_data[system_id]["total_devices"] = (
connected_count + guest_connected_count
)
if (
time.time()
> (self._last_speedtest + (60 * 60 * self.speedtest_interval))
and self.auto_speedtest == True
and self.hass.state == CoreState.running
):
for system_id, system in system_data.items():
speedtest_result = await self.api.run_speed_test(
system_id=system_id
)
system_data[system_id]["speedtest"] = speedtest_result
self._last_speedtest = time.time()
elif self._force_speed_update:
speedtest_result = await self.api.run_speed_test(system_id=system_id)
system_data[system_id]["speedtest"] = speedtest_result
self._force_speed_update = None
return system_data
except GoogleWifiException as error:
session = aiohttp_client.async_create_clientsession(self.hass)
self.api = GoogleWifi(refresh_token=self.refresh_token, session=session)
except GoogleHomeIgnoreDevice as error:
raise UpdateFailed(f"Error connecting to GoogleWifi: {error}") from error
except ConnectionError as error:
raise PlatformNotReady(
f"Error connecting to GoogleWifi: {error}"
) from error
except ValueError as error:
raise ConfigEntryNotReady(
f"Invalid data from GoogleWifi: {error}"
) from error