async def set_equalizer(self, token, low_gain=0, high_gain=0):
"""Set equalizer db gain."""
endpoint = "setup/user_eq/set_equalizer"
returnvalue = False
data = {
"low_shelf": {
"gain_db": low_gain
},
"high_shelf": {
"gain_db": high_gain
},
}
result = await gdh_request(
schema="https",
host=self.host,
port=CASTSECPORT,
token=token,
endpoint=endpoint,
method="post",
loop=self.loop,
session=self.session,
json_data=data,
headers=HEADERS,
json=False,
)
try:
if result.status == 200:
returnvalue = True
except AttributeError:
msg = "Error connecting to - {}".format(self.host)
log.error(msg)
return returnvalue
async def forget_network(self, token, wpa_id):
"""Forget a network."""
endpoint = "setup/forget_wifi"
returnvalue = False
data = {"wpa_id": int(wpa_id)}
returnvalue = False
result = await gdh_request(
schema="https",
host=self.host,
port=CASTSECPORT,
token=token,
endpoint=endpoint,
method="post",
loop=self.loop,
session=self.session,
json_data=data,
headers=HEADERS,
json=False,
)
try:
if result.status == 200:
returnvalue = True
except AttributeError:
msg = "Error connecting to - {}".format(self.host)
log.error(msg)
return returnvalue
async def set_alarm_volume(self, token, volume):
"""Set the alarm volume for the device."""
data = {"volume": volume}
endpoint = "setup/assistant/alarms/volume"
returnvalue = False
result = await gdh_request(
schema="https",
host=self.host,
port=CASTSECPORT,
token=token,
endpoint=endpoint,
method="post",
loop=self.loop,
session=self.session,
json_data=data,
headers=HEADERS,
json=False,
)
try:
if result.status == 200:
returnvalue = True
except AttributeError:
msg = "Error connecting to - {}".format(self.host)
log.error(msg)
return returnvalue
async def set_discovery_enabled(self, token):
"""Enable bluetooth discoverablility."""
endpoint = "setup/bluetooth/discovery"
data = {"enable_discovery": True}
returnvalue = False
result = await gdh_request(
schema="https",
host=self.host,
port=CASTSECPORT,
token=token,
endpoint=endpoint,
method="post",
loop=self.loop,
session=self.session,
json_data=data,
headers=HEADERS,
json=False,
)
try:
if result.status == 200:
returnvalue = True
except AttributeError:
msg = "Error connecting to - {}".format(self.host)
log.error(msg)
return returnvalue
async def scan_for_devices(self, token):
"""Scan for bluetooth devices."""
endpoint = "setup/bluetooth/scan"
data = {"enable": True, "clear_results": True, "timeout": 5}
returnvalue = False
result = await gdh_request(
schema="https",
host=self.host,
port=CASTSECPORT,
token=token,
endpoint=endpoint,
method="post",
loop=self.loop,
session=self.session,
json_data=data,
headers=HEADERS,
json=False,
)
try:
if result.status == 200:
returnvalue = True
except AttributeError:
msg = "Error connecting to - {}".format(self.host)
log.error(msg)
return returnvalue
async def forget_paired_device(self, token, mac_address):
"""Forget a paired device."""
endpoint = "setup/bluetooth/bond"
data = {"bond": False, "mac_address": mac_address}
returnvalue = False
result = await gdh_request(
schema="https",
host=self.host,
port=CASTSECPORT,
token=token,
endpoint=endpoint,
method="post",
loop=self.loop,
session=self.session,
json_data=data,
headers=HEADERS,
json=False,
)
try:
if result.status == 200:
returnvalue = True
except AttributeError:
msg = "Error connecting to - {}".format(self.host)
log.error(msg)
return returnvalue
async def pair_with_mac(self, token, mac_address):
"""Pair with bluetooth device."""
endpoint = "setup/bluetooth/scan"
data = {"connect": True, "mac_address": mac_address, "profile": 2}
returnvalue = False
result = await gdh_request(
schema="https",
host=self.host,
port=CASTSECPORT,
token=token,
endpoint=endpoint,
method="post",
loop=self.loop,
session=self.session,
json_data=data,
headers=HEADERS,
json=False,
)
try:
if result.status == 200:
returnvalue = True
except AttributeError:
msg = "Error connecting to - {}".format(self.host)
log.error(msg)
return returnvalue
async def control_notifications(self, token, active):
"""Set control_notifications option."""
endpoint = "setup/set_eureka_info"
value = 1 if active else 2
data = {"settings": {"control_notifications": value}}
returnvalue = False
result = await gdh_request(
schema="https",
host=self.host,
port=CASTSECPORT,
token=token,
endpoint=endpoint,
method="post",
loop=self.loop,
session=self.session,
json_data=data,
headers=HEADERS,
json=False,
)
try:
if result.status == 200:
returnvalue = True
except AttributeError:
msg = "Error connecting to - {}".format(self.host)
log.error(msg)
return returnvalue
async def reboot(self, token, mode="now"):
"""Reboot the device."""
endpoint = "setup/reboot"
supported_modes = ["now", "fdr"]
returnvalue = False
if mode not in supported_modes:
log_msg = "Mode {} is not supported.".format(mode)
log.error(log_msg)
return returnvalue
data = {"params": mode}
result = await gdh_request(
schema="https",
host=self.host,
port=CASTSECPORT,
token=token,
endpoint=endpoint,
method="post",
loop=self.loop,
session=self.session,
json_data=data,
headers=HEADERS,
json=False,
)
try:
if result.status == 200:
returnvalue = True
except AttributeError:
msg = "Error connecting to - {}".format(self.host)
log.error(msg)
return returnvalue
async def get_wifi_info(self):
"""Get the Wi-Fi status of the device."""
if self.wifi_host is None:
await self.get_host()
try:
response = await gdh_request(
host=self.wifi_host,
endpoint=self.endpoint,
session=self.session,
loop=self.loop,
)
self._wifi_info = response
# pylint: disable=W0703
except Exception as error: # pylint: disable=W0703
log.error(error)
return self._wifi_info
async def scan_for_wifi(self, token):
"""Scan for nearby wifi networks."""
endpoint = "setup/scan_wifi"
returnvalue = False
result = await gdh_request(
schema="https",
host=self.host,
port=CASTSECPORT,
token=token,
endpoint=endpoint,
method="post",
loop=self.loop,
session=self.session,
headers=HEADERS,
json=False,
)
try:
if result.status == 200:
returnvalue = True
except AttributeError:
msg = "Error connecting to - {}".format(self.host)
log.error(msg)
return returnvalue
async def set_eureka_info(self, token, data):
"""Set eureka info."""
endpoint = "setup/set_eureka_info"
returnvalue = False
result = await gdh_request(
schema="https",
host=self.host,
port=CASTSECPORT,
token=token,
endpoint=endpoint,
method="post",
loop=self.loop,
session=self.session,
json_data=data,
headers=HEADERS,
json=False,
)
try:
if result.status == 200:
returnvalue = True
except AttributeError:
msg = "Error connecting to - {}".format(self.host)
log.error(msg)
return returnvalue
async def get_clients(self):
"""Return clients form the network."""
import requests
import asyncio
import aiohttp
from socket import gaierror
self._clients = []
if self.info.wifi_host is None:
async with self.session:
await self.info.get_host()
if self.info.wifi_host is None:
await log.error("Host is 'None', host can not be 'None'")
return self._clients
endpoint = WIFIAPIPREFIX + "diagnostic-report"
url = API.format(schema="http",
host=self.info.wifi_host,
port=":80",
endpoint=endpoint)
try:
response = requests.request("GET", url)
all_clients = response.text
all_clients = all_clients.split("/proc/net/arp")[1]
all_clients = all_clients.split("/proc/slabinfo")[0]
all_clients = all_clients.splitlines()
for device in all_clients[1:-2]:
host = device.split()[0]
mac = device.split()[3]
info = {"ip": host, "mac": mac}
self._clients.append(info)
except (TypeError, KeyError, IndexError) as error:
msg = "Error parsing information - {}".format(error)
log.error(msg)
except (
asyncio.TimeoutError,
aiohttp.ClientError,
gaierror,
asyncio.CancelledError,
) as error:
msg = "{} - {}".format(url, error)
log.error(msg)
except Exception as error: # pylint: disable=W0703
log.error(error)
return self._clients
async def gdh_request(
host,
schema=None,
port=None,
token=None,
endpoint=None,
json=True,
session=None,
loop=None,
headers=None,
data=None,
json_data=None,
params=None,
method="get",
):
"""Web request."""
import asyncio
import aiohttp
import async_timeout
from socket import gaierror
from googledevices.utils.const import API
import googledevices.utils.log as log
if schema is None:
schema = "http"
if port is not None:
port = ":{port}".format(port=port)
else:
port = ""
url = API.format(schema=schema, host=host, port=port, endpoint=endpoint)
result = None
if token is not None:
if headers is None:
headers = {}
headers["cast-local-authorization-token"] = token
if session is None:
session = gdh_session()
if loop is None:
loop = gdh_loop()
try:
async with async_timeout.timeout(8, loop=loop):
if method == "post":
webrequest = await session.post(
url, json=json_data, data=data, params=params, headers=headers, ssl=False
)
else:
webrequest = await session.get(
url, json=json_data, data=data, params=params, headers=headers, ssl=False
)
if json:
result = await webrequest.json()
else:
result = webrequest
except (TypeError, KeyError, IndexError) as error:
log.error("Error parsing information - {}".format(error))
except asyncio.TimeoutError:
log.error("Timeout contacting {}".format(url))
except asyncio.CancelledError:
log.error("Cancellation error contacting {}".format(url))
except aiohttp.ClientError as error:
log.error("ClientError contacting {} - {}".format(url, error))
except gaierror as error:
log.error("I/O error contacting {} - {}".format(url, error))
except Exception as error: # pylint: disable=W0703
log.error("Unexpected error contacting {} - {}".format(url, error))
return result
