OwnTracks Config Entry

homeassistant/components/device_tracker/__init__.py

@@ -181,6 +181,9 @@ async def async_setup_platform(p_type, p_config, disc_info=None):
                 setup = await hass.async_add_job(
                     platform.setup_scanner, hass, p_config, tracker.see,
                     disc_info)
+            elif hasattr(platform, 'async_setup_entry'):
+                setup = await platform.async_setup_entry(
+                    hass, p_config, tracker.async_see)
             else:
                 raise HomeAssistantError("Invalid device_tracker platform.")
 
@@ -196,6 +199,8 @@ async def async_setup_platform(p_type, p_config, disc_info=None):
         except Exception:  # pylint: disable=broad-except
             _LOGGER.exception("Error setting up platform %s", p_type)
 
+    hass.data[DOMAIN] = async_setup_platform
+
     setup_tasks = [async_setup_platform(p_type, p_config) for p_type, p_config
                    in config_per_platform(config, DOMAIN)]
     if setup_tasks:
@@ -229,6 +234,12 @@ async def async_see_service(call):
     return True
 
 
+async def async_setup_entry(hass, entry):
+    """Set up an entry."""
+    await hass.data[DOMAIN](entry.domain, entry)
+    return True
+
+
 class DeviceTracker:
     """Representation of a device tracker."""
 

homeassistant/components/device_tracker/owntracks.py

@@ -7,55 +7,29 @@
 import base64
 import json
 import logging
-from collections import defaultdict
 
-import voluptuous as vol
-
-from homeassistant.components import mqtt
-import homeassistant.helpers.config_validation as cv
 from homeassistant.components import zone as zone_comp
 from homeassistant.components.device_tracker import (
-    PLATFORM_SCHEMA, ATTR_SOURCE_TYPE, SOURCE_TYPE_BLUETOOTH_LE,
-    SOURCE_TYPE_GPS
+    ATTR_SOURCE_TYPE, SOURCE_TYPE_BLUETOOTH_LE, SOURCE_TYPE_GPS
 )
+from homeassistant.components.owntracks import DOMAIN as OT_DOMAIN
 from homeassistant.const import STATE_HOME
-from homeassistant.core import callback
 from homeassistant.util import slugify, decorator
 
-REQUIREMENTS = ['libnacl==1.6.1']
+
+DEPENDENCIES = ['owntracks']
 
 _LOGGER = logging.getLogger(__name__)
 
 HANDLERS = decorator.Registry()
 
-BEACON_DEV_ID = 'beacon'
-
-CONF_MAX_GPS_ACCURACY = 'max_gps_accuracy'
-CONF_SECRET = 'secret'
-CONF_WAYPOINT_IMPORT = 'waypoints'
-CONF_WAYPOINT_WHITELIST = 'waypoint_whitelist'
-CONF_MQTT_TOPIC = 'mqtt_topic'
-CONF_REGION_MAPPING = 'region_mapping'
-CONF_EVENTS_ONLY = 'events_only'
-
-DEPENDENCIES = ['mqtt']
-
-DEFAULT_OWNTRACKS_TOPIC = 'owntracks/#'
-REGION_MAPPING = {}
 
-PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
-    vol.Optional(CONF_MAX_GPS_ACCURACY): vol.Coerce(float),
-    vol.Optional(CONF_WAYPOINT_IMPORT, default=True): cv.boolean,
-    vol.Optional(CONF_EVENTS_ONLY, default=False): cv.boolean,
-    vol.Optional(CONF_MQTT_TOPIC, default=DEFAULT_OWNTRACKS_TOPIC):
-        mqtt.valid_subscribe_topic,
-    vol.Optional(CONF_WAYPOINT_WHITELIST): vol.All(
-        cv.ensure_list, [cv.string]),
-    vol.Optional(CONF_SECRET): vol.Any(
-        vol.Schema({vol.Optional(cv.string): cv.string}),
-        cv.string),
-    vol.Optional(CONF_REGION_MAPPING, default=REGION_MAPPING): dict
-})
+async def async_setup_entry(hass, entry, async_see):
+    """Set up OwnTracks based off an entry."""
+    hass.data[OT_DOMAIN]['context'].async_see = async_see
+    hass.helpers.dispatcher.async_dispatcher_connect(
+        OT_DOMAIN, async_handle_message)
+    return True
 
 
 def get_cipher():
@@ -72,29 +46,6 @@ def decrypt(ciphertext, key):
     return (KEYLEN, decrypt)
 
 
-async def async_setup_scanner(hass, config, async_see, discovery_info=None):
-    """Set up an OwnTracks tracker."""
-    context = context_from_config(async_see, config)
-
-    async def async_handle_mqtt_message(topic, payload, qos):
-        """Handle incoming OwnTracks message."""
-        try:
-            message = json.loads(payload)
-        except ValueError:
-            # If invalid JSON
-            _LOGGER.error("Unable to parse payload as JSON: %s", payload)
-            return
-
-        message['topic'] = topic
-
-        await async_handle_message(hass, context, message)
-
-    await mqtt.async_subscribe(
-        hass, context.mqtt_topic, async_handle_mqtt_message, 1)
-
-    return True
-
-
 def _parse_topic(topic, subscribe_topic):
     """Parse an MQTT topic {sub_topic}/user/dev, return (user, dev) tuple.
 
@@ -202,93 +153,6 @@ def _decrypt_payload(secret, topic, ciphertext):
         return None
 
 
-def context_from_config(async_see, config):
-    """Create an async context from Home Assistant config."""
-    max_gps_accuracy = config.get(CONF_MAX_GPS_ACCURACY)
-    waypoint_import = config.get(CONF_WAYPOINT_IMPORT)
-    waypoint_whitelist = config.get(CONF_WAYPOINT_WHITELIST)
-    secret = config.get(CONF_SECRET)
-    region_mapping = config.get(CONF_REGION_MAPPING)
-    events_only = config.get(CONF_EVENTS_ONLY)
-    mqtt_topic = config.get(CONF_MQTT_TOPIC)
-
-    return OwnTracksContext(async_see, secret, max_gps_accuracy,
-                            waypoint_import, waypoint_whitelist,
-                            region_mapping, events_only, mqtt_topic)
-
-
-class OwnTracksContext:
-    """Hold the current OwnTracks context."""
-
-    def __init__(self, async_see, secret, max_gps_accuracy, import_waypoints,
-                 waypoint_whitelist, region_mapping, events_only, mqtt_topic):
-        """Initialize an OwnTracks context."""
-        self.async_see = async_see
-        self.secret = secret
-        self.max_gps_accuracy = max_gps_accuracy
-        self.mobile_beacons_active = defaultdict(set)
-        self.regions_entered = defaultdict(list)
-        self.import_waypoints = import_waypoints
-        self.waypoint_whitelist = waypoint_whitelist
-        self.region_mapping = region_mapping
-        self.events_only = events_only
-        self.mqtt_topic = mqtt_topic
-
-    @callback
-    def async_valid_accuracy(self, message):
-        """Check if we should ignore this message."""
-        acc = message.get('acc')
-
-        if acc is None:
-            return False
-
-        try:
-            acc = float(acc)
-        except ValueError:
-            return False
-
-        if acc == 0:
-            _LOGGER.warning(
-                "Ignoring %s update because GPS accuracy is zero: %s",
-                message['_type'], message)
-            return False
-
-        if self.max_gps_accuracy is not None and \
-                acc > self.max_gps_accuracy:
-            _LOGGER.info("Ignoring %s update because expected GPS "
-                         "accuracy %s is not met: %s",
-                         message['_type'], self.max_gps_accuracy,
-                         message)
-            return False
-
-        return True
-
-    async def async_see_beacons(self, hass, dev_id, kwargs_param):
-        """Set active beacons to the current location."""
-        kwargs = kwargs_param.copy()
-
-        # Mobile beacons should always be set to the location of the
-        # tracking device. I get the device state and make the necessary
-        # changes to kwargs.
-        device_tracker_state = hass.states.get(
-            "device_tracker.{}".format(dev_id))
-
-        if device_tracker_state is not None:
-            acc = device_tracker_state.attributes.get("gps_accuracy")
-            lat = device_tracker_state.attributes.get("latitude")
-            lon = device_tracker_state.attributes.get("longitude")
-            kwargs['gps_accuracy'] = acc
-            kwargs['gps'] = (lat, lon)
-
-        # the battery state applies to the tracking device, not the beacon
-        # kwargs location is the beacon's configured lat/lon
-        kwargs.pop('battery', None)
-        for beacon in self.mobile_beacons_active[dev_id]:
-            kwargs['dev_id'] = "{}_{}".format(BEACON_DEV_ID, beacon)
-            kwargs['host_name'] = beacon
-            await self.async_see(**kwargs)
-
-
 @HANDLERS.register('location')
 async def async_handle_location_message(hass, context, message):
     """Handle a location message."""
@@ -485,6 +349,8 @@ async def async_handle_message(hass, context, message):
     """Handle an OwnTracks message."""
     msgtype = message.get('_type')
 
+    _LOGGER.debug("Received %s", message)
+
     handler = HANDLERS.get(msgtype, async_handle_unsupported_msg)
 
     await handler(hass, context, message)

homeassistant/components/owntracks/.translations/en.json

@@ -0,0 +1,17 @@
+{
+    "config": {
+        "abort": {
+            "one_instance_allowed": "Only a single instance is necessary."
+        },
+        "create_entry": {
+            "default": "\n\nOn Android, open [the OwnTracks app]({android_url}), go to preferences -> connection. Change the following settings:\n - Mode: Private HTTP\n - Host: {webhook_url}\n - Identification:\n   - Username: `<Your name>`\n   - Device ID: `<Your device name>`\n\nOn iOS, open [the OwnTracks app]({ios_url}), tap (i) icon in top left -> settings. Change the following settings:\n - Mode: HTTP\n - URL: {webhook_url}\n - Turn on authentication\n - UserID: `<Your name>`\n\n{secret}\n\nSee [the documentation]({docs_url}) for more information."
+        },
+        "step": {
+            "user": {
+                "description": "Are you sure you want to set up OwnTracks?",
+                "title": "Set up OwnTracks"
+            }
+        },
+        "title": "OwnTracks"
+    }
+}