text: """
  Support for interfacing to iTunes API.
  
  For more details about this platform, please refer to the documentation at
  https://home-assistant.io/components/media_player.itunes/
  """
  import logging
  
  import requests
  import voluptuous as vol
  
  from homeassistant.components.media_player import (
      MEDIA_TYPE_MUSIC, MEDIA_TYPE_PLAYLIST, SUPPORT_NEXT_TRACK, SUPPORT_PAUSE,
      SUPPORT_PLAY_MEDIA, SUPPORT_PREVIOUS_TRACK, SUPPORT_SEEK, SUPPORT_TURN_OFF,
      SUPPORT_TURN_ON, SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_SET, PLATFORM_SCHEMA,
      SUPPORT_PLAY, MediaPlayerDevice)
  from homeassistant.const import (
      STATE_IDLE, STATE_OFF, STATE_ON, STATE_PAUSED, STATE_PLAYING, CONF_NAME,
      CONF_HOST, CONF_PORT, CONF_SSL)
  import homeassistant.helpers.config_validation as cv
  
  _LOGGER = logging.getLogger(__name__)
  
  DEFAULT_NAME = 'iTunes'
  DEFAULT_PORT = 8181
  DEFAULT_TIMEOUT = 10
  DEFAULT_SSL = False
  DOMAIN = 'itunes'
  
  SUPPORT_ITUNES = SUPPORT_PAUSE | SUPPORT_VOLUME_SET | SUPPORT_VOLUME_MUTE | \
      SUPPORT_PREVIOUS_TRACK | SUPPORT_NEXT_TRACK | SUPPORT_SEEK | \
      SUPPORT_PLAY_MEDIA | SUPPORT_PLAY
  
  SUPPORT_AIRPLAY = SUPPORT_VOLUME_SET | SUPPORT_TURN_ON | SUPPORT_TURN_OFF
  
  PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
      vol.Required(CONF_HOST): cv.string,
      vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
      vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port,
      vol.Optional(CONF_SSL, default=DEFAULT_SSL): cv.boolean,
  })
  
  
  class Itunes(object):
      """The iTunes API client."""
  
      def __init__(self, host, port, use_ssl):
          """Initialize the iTunes device."""
          self.host = host
          self.port = port
          self.use_ssl = use_ssl
  
      @property
      def _base_url(self):
          """Return the base url for endpoints."""
          if self.use_ssl:
              uri_scheme = 'https://'
          else:
              uri_scheme = 'http://'
  
          if self.port:
              return '{}{}:{}'.format(uri_scheme, self.host, self.port)
  
          return '{}{}'.format(uri_scheme, self.host)
  
      def _request(self, method, path, params=None):
          """Make the actual request and return the parsed response."""
          url = '{}{}'.format(self._base_url, path)
  
          try:
              if method == 'GET':
                  response = requests.get(url, timeout=DEFAULT_TIMEOUT)
              elif method == 'POST':
                  response = requests.put(url, params, timeout=DEFAULT_TIMEOUT)
              elif method == 'PUT':
                  response = requests.put(url, params, timeout=DEFAULT_TIMEOUT)
              elif method == 'DELETE':
                  response = requests.delete(url, timeout=DEFAULT_TIMEOUT)
  
              return response.json()
          except requests.exceptions.HTTPError:
              return {'player_state': 'error'}
          except requests.exceptions.RequestException:
              return {'player_state': 'offline'}
  
      def _command(self, named_command):
          """Make a request for a controlling command."""
          return self._request('PUT', '/' + named_command)
  
      def now_playing(self):
          """Return the current state."""
          return self._request('GET', '/now_playing')
  
      def set_volume(self, level):
          """Set the volume and returns the current state, level 0-100."""
          return self._request('PUT', '/volume', {'level': level})
  
      def set_muted(self, muted):
          """Mute and returns the current state, muted True or False."""
          return self._request('PUT', '/mute', {'muted': muted})
  
      def play(self):
          """Set playback to play and returns the current state."""
          return self._command('play')
  
      def pause(self):
          """Set playback to paused and returns the current state."""
          return self._command('pause')
  
      def next(self):
          """Skip to the next track and returns the current state."""
          return self._command('next')
  
      def previous(self):
          """Skip back and returns the current state."""
          return self._command('previous')
  
      def play_playlist(self, playlist_id_or_name):
          """Set a playlist to be current and returns the current state."""
          response = self._request('GET', '/playlists')
          playlists = response.get('playlists', [])
  
          found_playlists = \
              [playlist for playlist in playlists if
               (playlist_id_or_name in [playlist["name"], playlist["id"]])]
  
          if found_playlists:
              playlist = found_playlists[0]
              path = '/playlists/' + playlist['id'] + '/play'
              return self._request('PUT', path)
  
      def artwork_url(self):
          """Return a URL of the current track's album art."""
          return self._base_url + '/artwork'
  
      def airplay_devices(self):
          """Return a list of AirPlay devices."""
          return self._request('GET', '/airplay_devices')
  
      def airplay_device(self, device_id):
          """Return an AirPlay device."""
          return self._request('GET', '/airplay_devices/' + device_id)
  
      def toggle_airplay_device(self, device_id, toggle):
          """Toggle airplay device on or off, id, toggle True or False."""
          command = 'on' if toggle else 'off'
          path = '/airplay_devices/' + device_id + '/' + command
          return self._request('PUT', path)
  
      def set_volume_airplay_device(self, device_id, level):
          """Set volume, returns current state of device, id,level 0-100."""
          path = '/airplay_devices/' + device_id + '/volume'
          return self._request('PUT', path, {'level': level})
  
  
  def setup_platform(hass, config, add_devices, discovery_info=None):
      """Set up the iTunes platform."""
      add_devices([
          ItunesDevice(
              config.get(CONF_NAME),
              config.get(CONF_HOST),
              config.get(CONF_PORT),
              config.get(CONF_SSL),
  
              add_devices
          )
      ])
  
  
  class ItunesDevice(MediaPlayerDevice):
      """Representation of an iTunes API instance."""
  
      def __init__(self, name, host, port, use_ssl, add_devices):
          """Initialize the iTunes device."""
          self._name = name
          self._host = host
          self._port = port
          self._use_ssl = use_ssl
          self._add_devices = add_devices
  
          self.client = Itunes(self._host, self._port, self._use_ssl)
  
          self.current_volume = None
          self.muted = None
          self.current_title = None
          self.current_album = None
          self.current_artist = None
          self.current_playlist = None
          self.content_id = None
  
          self.player_state = None
  
          self.airplay_devices = {}
  
          self.update()
  
      def update_state(self, state_hash):
          """Update all the state properties with the passed in dictionary."""
          self.player_state = state_hash.get('player_state', None)
  
          self.current_volume = state_hash.get('volume', 0)
          self.muted = state_hash.get('muted', None)
          self.current_title = state_hash.get('name', None)
          self.current_album = state_hash.get('album', None)
          self.current_artist = state_hash.get('artist', None)
          self.current_playlist = state_hash.get('playlist', None)
          self.content_id = state_hash.get('id', None)
  
      @property
      def name(self):
          """Return the name of the device."""
          return self._name
  
      @property
      def state(self):
          """Return the state of the device."""
          if self.player_state == 'offline' or self.player_state is None:
              return 'offline'
  
          if self.player_state == 'error':
              return 'error'
  
          if self.player_state == 'stopped':
              return STATE_IDLE
  
          if self.player_state == 'paused':
              return STATE_PAUSED
  
          return STATE_PLAYING
  
      def update(self):
          """Retrieve latest state."""
          now_playing = self.client.now_playing()
          self.update_state(now_playing)
  
          found_devices = self.client.airplay_devices()
          found_devices = found_devices.get('airplay_devices', [])
  
          new_devices = []
  
          for device_data in found_devices:
              device_id = device_data.get('id')
  
              if self.airplay_devices.get(device_id):
                  # update it
                  airplay_device = self.airplay_devices.get(device_id)
                  airplay_device.update_state(device_data)
              else:
                  # add it
                  airplay_device = AirPlayDevice(device_id, self.client)
                  airplay_device.update_state(device_data)
                  self.airplay_devices[device_id] = airplay_device
                  new_devices.append(airplay_device)
  
          if new_devices:
              self._add_devices(new_devices)
  
      @property
      def is_volume_muted(self):
          """Boolean if volume is currently muted."""
          return self.muted
  
      @property
      def volume_level(self):
          """Volume level of the media player (0..1)."""
          return self.current_volume/100.0
  
      @property
      def media_content_id(self):
          """Content ID of current playing media."""
          return self.content_id
  
      @property
      def media_content_type(self):
          """Content type of current playing media."""
          return MEDIA_TYPE_MUSIC
  
      @property
      def media_image_url(self):
          """Image url of current playing media."""
          if self.player_state in (STATE_PLAYING, STATE_IDLE, STATE_PAUSED) and \
             self.current_title is not None:
              return self.client.artwork_url()
  
          return 'https://cloud.githubusercontent.com/assets/260/9829355' \
              '/33fab972-58cf-11e5-8ea2-2ca74bdaae40.png'
  
      @property
      def media_title(self):
          """Title of current playing media."""
          return self.current_title
  
      @property
      def media_artist(self):
          """Artist of current playing media (Music track only)."""
          return self.current_artist
  
      @property
      def media_album_name(self):
          """Album of current playing media (Music track only)."""
          return self.current_album
  
      @property
      def media_playlist(self):
          """Title of the currently playing playlist."""
          return self.current_playlist
  
      @property
      def supported_features(self):
          """Flag media player features that are supported."""
          return SUPPORT_ITUNES
  
      def set_volume_level(self, volume):
          """Set volume level, range 0..1."""
          response = self.client.set_volume(int(volume * 100))
          self.update_state(response)
  
      def mute_volume(self, mute):
          """Mute (true) or unmute (false) media player."""
          response = self.client.set_muted(mute)
          self.update_state(response)
  
      def media_play(self):
          """Send media_play command to media player."""
          response = self.client.play()
          self.update_state(response)
  
      def media_pause(self):
          """Send media_pause command to media player."""
          response = self.client.pause()
          self.update_state(response)
  
      def media_next_track(self):
          """Send media_next command to media player."""
          response = self.client.next()
          self.update_state(response)
  
      def media_previous_track(self):
          """Send media_previous command media player."""
          response = self.client.previous()
          self.update_state(response)
  
      def play_media(self, media_type, media_id, **kwargs):
          """Send the play_media command to the media player."""
          if media_type == MEDIA_TYPE_PLAYLIST:
              response = self.client.play_playlist(media_id)
              self.update_state(response)
  
  
  class AirPlayDevice(MediaPlayerDevice):
      """Representation an AirPlay device via an iTunes API instance."""
  
      def __init__(self, device_id, client):
          """Initialize the AirPlay device."""
          self._id = device_id
          self.client = client
          self.device_name = "AirPlay"
          self.kind = None
          self.active = False
          self.selected = False
          self.volume = 0
          self.supports_audio = False
          self.supports_video = False
          self.player_state = None
  
      def update_state(self, state_hash):
          """Update all the state properties with the passed in dictionary."""
          if 'player_state' in state_hash:
              self.player_state = state_hash.get('player_state', None)
  
          if 'name' in state_hash:
              name = state_hash.get('name', '')
              self.device_name = (name + ' AirTunes Speaker').strip()
  
          if 'kind' in state_hash:
              self.kind = state_hash.get('kind', None)
  
          if 'active' in state_hash:
              self.active = state_hash.get('active', None)
  
          if 'selected' in state_hash:
              self.selected = state_hash.get('selected', None)
  
          if 'sound_volume' in state_hash:
              self.volume = state_hash.get('sound_volume', 0)
  
          if 'supports_audio' in state_hash:
              self.supports_audio = state_hash.get('supports_audio', None)
  
          if 'supports_video' in state_hash:
              self.supports_video = state_hash.get('supports_video', None)
  
      @property
      def name(self):
          """Return the name of the device."""
          return self.device_name
  
      @property
      def icon(self):
          """Return the icon to use in the frontend, if any."""
          if self.selected is True:
              return 'mdi:volume-high'
  
          return 'mdi:volume-off'
  
      @property
      def state(self):
          """Return the state of the device."""
          if self.selected is True:
              return STATE_ON
  
          return STATE_OFF
  
      def update(self):
          """Retrieve latest state."""
  
      @property
      def volume_level(self):
          """Return the volume."""
          return float(self.volume)/100.0
  
      @property
      def media_content_type(self):
          """Flag of media content that is supported."""
          return MEDIA_TYPE_MUSIC
  
      @property
      def supported_features(self):
          """Flag media player features that are supported."""
          return SUPPORT_AIRPLAY
  
      def set_volume_level(self, volume):
          """Set volume level, range 0..1."""
          volume = int(volume * 100)
          response = self.client.set_volume_airplay_device(self._id, volume)
          self.update_state(response)
  
      def turn_on(self):
          """Select AirPlay."""
          self.update_state({"selected": True})
          self.schedule_update_ha_state()
          response = self.client.toggle_airplay_device(self._id, True)
          self.update_state(response)
  
      def turn_off(self):
          """Deselect AirPlay."""
          self.update_state({"selected": False})
          self.schedule_update_ha_state()
          response = self.client.toggle_airplay_device(self._id, False)
          self.update_state(response)
  