--- layout: template title: API - pyatv.interface permalink: /api/interface/ link_group: api ---

# Module `pyatv.interface`

Public interface exposed by library.

This module contains all the interfaces that represents a generic Apple TV device and all its features.

Browse git

## Functions

`def retrieve_commands(obj: object)`

  Retrieve all commands and help texts from an API object.

## Classes

`class App (name: Optional[str], identifier: str)`

  Information about an app.

  Initialize a new App instance.

  Browse git

  ### Instance variables

  `var identifier -> str`

    Return a unique bundle id for the app.

  `var name -> Optional[str]`

    User friendly name of app.

`class AppleTV (max_calls: int = 0)`

  Base class representing an Apple TV.

  Listener interface: `pyatv.interfaces.DeviceListener`

  Initialize a new StateProducer instance.

  Browse git

  ### Ancestors

  - abc.ABC
  - pyatv.support.state_producer.StateProducer
  - typing.Generic

  ### Subclasses

  - pyatv.core.facade.FacadeAppleTV

  ### Instance variables

  `var apps -> Apps`

    Return apps interface.

  `var audio -> Audio`

    Return audio interface.

  `var device_info -> DeviceInfo`

    Return API for device information.

  `var features -> Features`

    Return features interface.

  `var keyboard -> Keyboard`

    Return keyboard interface.

  `var metadata -> Metadata`

    Return API for retrieving metadata from the Apple TV.

  `var power -> Power`

    Return API for power management.

  `var push_updater -> PushUpdater`

    Return API for handling push update from the Apple TV.

  `var remote_control -> RemoteControl`

    Return API for controlling the Apple TV.

  `var service -> BaseService`

    Return service used to connect to the Apple TV.

  `var settings -> Settings`

    Return device settings used by pyatv.

  `var stream -> Stream`

    Return API for streaming media.

  `var touch -> TouchGestures`

    Return touch gestures interface.

  `var user_accounts -> UserAccounts`

    Return user accounts interface.

  ### Methods

  `def close(self) -> Set[_asyncio.Task]`

    Close connection and release allocated resources.

  `async def connect(self) -> None`

    Initiate connection to device.

    No need to call it yourself, it's done automatically.

`class Apps`

  Base class for app handling.

  Browse git

  ### Subclasses

  - pyatv.core.facade.FacadeApps
  - pyatv.protocols.companion.CompanionApps

  ### Methods

  `async def app_list(self) -> List[App]`
    Feature: FeatureName.AppList, Supported by: Protocol.Companion

    Fetch a list of apps that can be launched.

  `async def launch_app(self, bundle_id_or_url: str) -> None`
    Feature: FeatureName.LaunchApp, Supported by: Protocol.Companion

    Launch an app based on bundle ID or URL.

`class ArtworkInfo (bytes: bytes, mimetype: str, width: int, height: int)`

  Artwork information.

  Browse git

  ### Ancestors

  - builtins.tuple

  ### Instance variables

  `var bytes -> bytes`

    Alias for field number 0

  `var height -> int`

    Alias for field number 3

  `var mimetype -> str`

    Alias for field number 1

  `var width -> int`

    Alias for field number 2

`class Audio (max_calls: int = 0)`

  Base class for audio functionality.

  Volume level is managed in percent where 0 is muted and 100 is max volume.

  Listener interface: `pyatv.interfaces.AudioListener`

  Initialize a new StateProducer instance.

  Browse git

  ### Ancestors

  - abc.ABC
  - pyatv.support.state_producer.StateProducer
  - typing.Generic

  ### Subclasses

  - pyatv.core.facade.FacadeAudio
  - pyatv.protocols.companion.CompanionAudio
  - pyatv.protocols.dmap.DmapAudio
  - pyatv.protocols.mrp.MrpAudio
  - pyatv.protocols.raop.RaopAudio

  ### Instance variables

  `var output_devices -> List[OutputDevice]`

    Return current list of output device IDs.

  `var volume -> float`

    Return current volume level.

    Range is in percent, i.e. [0.0-100.0].

  ### Methods

  `async def add_output_devices(self, *devices: List[str]) -> None`
    Feature: FeatureName.AddOutputDevices, Supported by: Protocol.MRP

    Add output devices.

  `async def remove_output_devices(self, *devices: List[str]) -> None`
    Feature: FeatureName.RemoveOutputDevices, Supported by: Protocol.MRP

    Remove output devices.

  `async def set_output_devices(self, *devices: List[str]) -> None`
    Feature: FeatureName.SetOutputDevices, Supported by: Protocol.MRP

    Set output devices.

  `async def set_volume(self, level: float) -> None`
    Feature: FeatureName.SetVolume, Supported by: Protocol.Companion, Protocol.MRP, Protocol.RAOP

    Change current volume level.

    Range is in percent, i.e. [0.0-100.0].

  `async def volume_down(self) -> None`
    Feature: FeatureName.VolumeDown, Supported by: Protocol.Companion, Protocol.DMAP, Protocol.MRP, Protocol.RAOP

    Decrease volume by one step.

    Step size is device dependent, but usually around 2.5% of the total volume range. It is not necessarily linear.

    Call will block until volume change has been acknowledged by the device (when possible and supported).

  `async def volume_up(self) -> None`
    Feature: FeatureName.VolumeUp, Supported by: Protocol.Companion, Protocol.DMAP, Protocol.MRP, Protocol.RAOP

    Increase volume by one step.

    Step size is device dependent, but usually around 2,5% of the total volume range. It is not necessarily linear.

    Call will block until volume change has been acknowledged by the device (when possible and supported).

`class AudioListener`

  Listener interface for audio updates.

  Browse git

  ### Ancestors

  - abc.ABC

  ### Subclasses

  - pyatv.scripts.atvscript.AudioPrinter

  ### Methods

  `def outputdevices_update(self, old_devices: List[OutputDevice], new_devices: List[OutputDevice]) -> None`

    Output devices were updated.

  `def volume_update(self, old_level: float, new_level: float) -> None`

    Device volume was updated.

`class BaseConfig (properties: Mapping[str, Mapping[str, Any]])`

  Representation of a device configuration.

  An instance of this class represents a single device. A device can have several services depending on the protocols it supports, e.g. DMAP or AirPlay.

  Initialize a new BaseConfig instance.

  Browse git

  ### Ancestors

  - abc.ABC

  ### Subclasses

  - AppleTV

  ### Instance variables

  `var address -> ipaddress.IPv4Address`

    IP address of device.

  `var all_identifiers -> List[str]`

    Return all unique identifiers for this device.

  `var deep_sleep -> bool`

    If device is in deep sleep.

  `var device_info -> DeviceInfo`

    Return general device information.

  `var identifier -> Optional[str]`

    Return the main identifier associated with this device.

  `var name -> str`

    Name of device.

  `var properties -> Mapping[str, Mapping[str, str]]`

    Return Zeroconf properties.

  `var ready -> bool`

    Return if configuration is ready, (at least one service with identifier).

  `var services -> List[BaseService]`

    Return all supported services.

  ### Methods

  `def add_service(self, service: BaseService) -> None`

    Add a new service.

    If the service already exists, it will be merged.

  `def apply(self, settings: Settings) -> None`

    Apply settings to configuration.

  `def get_service(self, protocol: Protocol) -> Optional[BaseService]`

    Look up a service based on protocol.

    If a service with the specified protocol is not available, None is returned.

  `def main_service(self, protocol: Optional[Protocol] = None) -> BaseService`

    Return suggested service used to establish connection.

  `def set_credentials(self, protocol: Protocol, credentials: str) -> bool`

    Set credentials for a protocol if it exists.

`class BaseService (identifier: Optional[str], protocol: Protocol, port: int, properties: Optional[Mapping[str, str]], credentials: Optional[str] = None, password: Optional[str] = None, enabled: bool = True)`

  Base class for protocol services.

  Initialize a new BaseService.

  Browse git

  ### Ancestors

  - abc.ABC

  ### Subclasses

  - ManualService
  - pyatv.core.MutableService

  ### Instance variables

  `var enabled -> bool`

    Return True if service is enabled.

  `var identifier -> Optional[str]`

    Return unique identifier associated with this service.

  `var pairing -> PairingRequirement`

    Return if pairing is required by service.

  `var port -> int`

    Return service port number.

  `var properties -> Mapping[str, str]`

    Return service Zeroconf properties.

  `var protocol -> Protocol`

    Return protocol type.

  `var requires_password -> bool`

    Return if a password is required to access service.

  ### Methods

  `def apply(self, settings: Mapping[str, Any]) -> None`

    Apply settings to service.

    Expects the same format as returned by settings() method. Unknown properties are silently ignored. Settings with a None value are also ignore (keeps original value).

  `def merge(self, other) -> None`

    Merge with other service of same type.

    Merge will only include credentials, password and properties.

  `def settings(self) -> Mapping[str, Any]`

    Return settings and their values.

`class DeviceInfo (device_info: Mapping[str, Any])`

  General information about device.

  Initialize a new DeviceInfo instance.

  Browse git

  ### Class variables

  `var OUTPUT_DEVICE_ID`

  ### Instance variables

  `var build_number -> Optional[str]`

    Operating system build number, e.g. 17K795.

  `var mac -> Optional[str]`

    Device MAC address.

  `var model -> DeviceModel`

    Hardware model name, e.g. 3, 4 or 4K.

  `var model_str -> str`

    Return model name as string.

    This property will return the model name as a string and fallback to `raw_model` if it is not available.

  `var operating_system -> OperatingSystem`

    Operating system running on device.

  `var output_device_id -> Optional[str]`

    Output device identifier.

  `var raw_model -> Optional[str]`

    Return raw model description.

    If `DeviceInfo.model` returns `DeviceModel.Unknown` then this property contains the raw model string (if any is available).

  `var version -> Optional[str]`

    Operating system version.

`class DeviceListener`

  Listener interface for generic device updates.

  Browse git

  ### Ancestors

  - abc.ABC

  ### Subclasses

  - pyatv.scripts.atvremote.DeviceListener
  - pyatv.scripts.atvscript.DevicePrinter

  ### Methods

  `def connection_closed(self) -> None`

    Device connection was (intentionally) closed.

  `def connection_lost(self, exception: Exception) -> None`

    Device was unexpectedly disconnected.

`class FeatureInfo (state: FeatureState, options: Optional[Dict[str, object]] = {})`

  Feature state and options.

  Browse git

  ### Ancestors

  - builtins.tuple

  ### Instance variables

  `var options -> Optional[Dict[str, object]]`

    Alias for field number 1

  `var state -> FeatureState`

    Alias for field number 0

`class Features`

  Base class for supported feature functionality.

  Browse git

  ### Subclasses

  - pyatv.core.facade.FacadeFeatures
  - pyatv.protocols.airplay.AirPlayFeatures
  - pyatv.protocols.companion.CompanionFeatures
  - pyatv.protocols.dmap.DmapFeatures
  - pyatv.protocols.mrp.MrpFeatures
  - pyatv.protocols.raop.RaopFeatures

  ### Methods

  `def all_features(self, include_unsupported=False) -> Dict[FeatureName, FeatureInfo]`

    Return state of all features.

  `def get_feature(self, feature_name: FeatureName) -> FeatureInfo`

    Return current state of a feature.

  `def in_state(self, states: Union[List[FeatureState], FeatureState], *feature_names: FeatureName) -> bool`

    Return if features are in a specific state.

    This method will return True if all given features are in the state specified by "states". If "states" is a list of states, it is enough for the feature to be in one of the listed states.

`class Keyboard (max_calls: int = 0)`

  Base class for keyboard handling.

  Listener interface: `pyatv.interfaces.KeyboardListener`

  Initialize a new StateProducer instance.

  Browse git

  ### Ancestors

  - abc.ABC
  - pyatv.support.state_producer.StateProducer
  - typing.Generic

  ### Subclasses

  - pyatv.core.facade.FacadeKeyboard
  - pyatv.protocols.companion.CompanionKeyboard

  ### Instance variables

  `var text_focus_state -> KeyboardFocusState`

    Return keyboard focus state.

  ### Methods

  `async def text_append(self, text: str) -> None`
    Feature: FeatureName.TextAppend, Supported by: Protocol.Companion

    Input text into virtual keyboard.

  `async def text_clear(self) -> None`
    Feature: FeatureName.TextClear, Supported by: Protocol.Companion

    Clear virtual keyboard text.

  `async def text_get(self) -> Optional[str]`
    Feature: FeatureName.TextGet, Supported by: Protocol.Companion

    Get current virtual keyboard text.

  `async def text_set(self, text: str) -> None`
    Feature: FeatureName.TextSet, Supported by: Protocol.Companion

    Replace text in virtual keyboard.

`class KeyboardListener`

  Listener interface for keyboard updates.

  Browse git

  ### Ancestors

  - abc.ABC

  ### Subclasses

  - pyatv.scripts.atvscript.KeyboardPrinter

  ### Methods

  `def focusstate_update(self, old_state: KeyboardFocusState, new_state: KeyboardFocusState) -> None`

    Keyboard focus state was updated.

`class MediaMetadata (title: Optional[str] = None, artist: Optional[str] = None, album: Optional[str] = None, artwork: Optional[bytes] = None, duration: Optional[float] = None)`

  Container for media (e.g. audio or video) metadata.

  Browse git

  ### Class variables

  `var album -> Optional[str]`
  `var artist -> Optional[str]`
  `var artwork -> Optional[bytes]`
  `var duration -> Optional[float]`
  `var title -> Optional[str]`
`class Metadata`

  Base class for retrieving metadata from an Apple TV.

  Browse git

  ### Subclasses

  - pyatv.core.facade.FacadeMetadata
  - pyatv.protocols.dmap.DmapMetadata
  - pyatv.protocols.mrp.MrpMetadata
  - pyatv.protocols.raop.RaopMetadata

  ### Instance variables

  `var app -> Optional[App]`

    Return information about current app playing something.

    Do note that this property returns which app is currently playing something and not which app is currently active. If nothing is playing, the corresponding feature will be unavailable.

  `var artwork_id -> str`

    Return a unique identifier for current artwork.

  `var device_id -> Optional[str]`

    Return a unique identifier for current device.

  ### Methods

  `async def artwork(self, width: Optional[int] = 512, height: Optional[int] = None) -> Optional[ArtworkInfo]`
    Feature: FeatureName.Artwork, Supported by: Protocol.DMAP, Protocol.MRP

    Return artwork for what is currently playing (or None).

    The parameters "width" and "height" makes it possible to request artwork of a specific size. This is just a request, the device might impose restrictions and return artwork of a different size. Set both parameters to None to request default size. Set one of them and let the other one be None to keep original aspect ratio.

  `async def playing(self) -> Playing`

    Return what is currently playing.

`class OutputDevice (name: Optional[str], identifier: str)`

  Information about an output device.

  Initialize a new OutputDevice instance.

  Browse git

  ### Instance variables

  `var identifier -> str`

    Return a unique id for the output device.

  `var name -> Optional[str]`

    User friendly name of output device.

`class PairingHandler (session_manager: pyatv.support.http.ClientSessionManager, service: BaseService)`

  Base class for API used to pair with an Apple TV.

  Initialize a new instance of PairingHandler.

  Browse git

  ### Ancestors

  - abc.ABC

  ### Subclasses

  - pyatv.protocols.airplay.pairing.AirPlayPairingHandler
  - pyatv.protocols.companion.pairing.CompanionPairingHandler
  - pyatv.protocols.dmap.pairing.DmapPairingHandler
  - pyatv.protocols.mrp.pairing.MrpPairingHandler

  ### Instance variables

  `var device_provides_pin -> bool`

    Return True if remote device presents PIN code, else False.

  `var has_paired -> bool`

    If a successful pairing has been performed.

    The value will be reset when stop() is called.

  `var service -> BaseService`

    Return service used for pairing.

  ### Methods

  `async def begin(self) -> None`

    Start pairing process.

  `async def close(self) -> None`

    Call to free allocated resources after pairing.

  `async def finish(self) -> None`

    Stop pairing process.

  `def pin(self, pin) -> None`

    Pin code used for pairing.

`class Playing (media_type: MediaType = MediaType.Unknown, device_state: DeviceState = DeviceState.Idle, title: Optional[str] = None, artist: Optional[str] = None, album: Optional[str] = None, genre: Optional[str] = None, total_time: Optional[int] = None, position: Optional[int] = None, shuffle: Optional[ShuffleState] = None, repeat: Optional[RepeatState] = None, hash: Optional[str] = None, series_name: Optional[str] = None, season_number: Optional[int] = None, episode_number: Optional[int] = None, content_identifier: Optional[str] = None, itunes_store_identifier: Optional[int] = None)`

  Base class for retrieving what is currently playing.

  Initialize a new Playing instance.

  Browse git

  ### Ancestors

  - abc.ABC

  ### Instance variables

  `var album -> Optional[str]`

    Album of the currently playing song.

  `var artist -> Optional[str]`

    Artist of the currently playing song.

  `var content_identifier -> Optional[str]`

    Content identifier (app specific).

  `var device_state -> DeviceState`

    Device state, e.g. playing or paused.

  `var episode_number -> Optional[int]`

    Episode number of TV series.

  `var genre -> Optional[str]`

    Genre of the currently playing song.

  `var hash -> str`

    Create a unique hash for what is currently playing.

    The hash is based on title, artist, album and total time. It should always be the same for the same content, but it is not guaranteed.

  `var itunes_store_identifier -> Optional[int]`

    Itunes Store identifier.

  `var media_type -> MediaType`

    Type of media is currently playing, e.g. video, music.

  `var position -> Optional[int]`

    Position in the playing media (seconds).

  `var repeat -> Optional[RepeatState]`

    Repeat mode.

  `var season_number -> Optional[int]`

    Season number of TV series.

  `var series_name -> Optional[str]`

    Title of TV series.

  `var shuffle -> Optional[ShuffleState]`

    If shuffle is enabled or not.

  `var title -> Optional[str]`

    Title of the current media, e.g. movie or song name.

  `var total_time -> Optional[int]`

    Total play time in seconds.

`class Power (max_calls: int = 0)`

  Base class for retrieving power state from an Apple TV.

  Listener interface: `pyatv.interfaces.PowerListener`

  Initialize a new StateProducer instance.

  Browse git

  ### Ancestors

  - abc.ABC
  - pyatv.support.state_producer.StateProducer
  - typing.Generic

  ### Subclasses

  - pyatv.core.facade.FacadePower
  - pyatv.protocols.companion.CompanionPower
  - pyatv.protocols.mrp.MrpPower

  ### Instance variables

  `var power_state -> PowerState`

    Return device power state.

  ### Methods

  `async def turn_off(self, await_new_state: bool = False) -> None`
    Feature: FeatureName.TurnOff, Supported by: Protocol.Companion, Protocol.MRP

    Turn device off.

  `async def turn_on(self, await_new_state: bool = False) -> None`
    Feature: FeatureName.TurnOn, Supported by: Protocol.Companion, Protocol.MRP

    Turn device on.

`class PowerListener`

  Listener interface for power updates.

  Browse git

  ### Ancestors

  - abc.ABC

  ### Subclasses

  - pyatv.core.facade.FacadePower
  - pyatv.scripts.atvremote.PowerListener
  - pyatv.scripts.atvscript.PowerPrinter

  ### Methods

  `def powerstate_update(self, old_state: PowerState, new_state: PowerState) -> None`

    Device power state was updated.

`class PushListener`

  Listener interface for push updates.

  Browse git

  ### Ancestors

  - abc.ABC

  ### Subclasses

  - pyatv.core.facade.FacadePushUpdater
  - pyatv.scripts.atvremote.PushListener
  - pyatv.scripts.atvscript.PushPrinter

  ### Methods

  `def playstatus_error(self, updater, exception: Exception) -> None`

    Inform about an error when updating play status.

  `def playstatus_update(self, updater, playstatus: Playing) -> None`

    Inform about changes to what is currently playing.

`class PushUpdater (max_calls: int = 0)`

  Base class for push/async updates from an Apple TV.

  A `PushUpdater` shall only publish update in case the state actually changes.

  Listener interface: `PushListener`.

  Initialize a new StateProducer instance.

  Browse git

  ### Ancestors

  - abc.ABC
  - pyatv.support.state_producer.StateProducer
  - typing.Generic

  ### Subclasses

  - pyatv.core.AbstractPushUpdater
  - pyatv.core.facade.FacadePushUpdater

  ### Instance variables

  `var active -> bool`

    Return if push updater has been started.

  ### Methods

  `def start(self, initial_delay: int = 0) -> None`
    Feature: FeatureName.PushUpdates, Supported by:

    Begin to listen to updates.

    If an error occurs, start must be called again.

  `def stop(self) -> None`

    No longer forward updates to listener.

`class RemoteControl`

  Base class for API used to control an Apple TV.

  Browse git

  ### Subclasses

  - pyatv.core.facade.FacadeRemoteControl
  - pyatv.protocols.airplay.AirPlayRemoteControl
  - pyatv.protocols.companion.CompanionRemoteControl
  - pyatv.protocols.dmap.DmapRemoteControl
  - pyatv.protocols.mrp.MrpRemoteControl
  - pyatv.protocols.raop.RaopRemoteControl

  ### Methods

  `async def channel_down(self) -> None`
    Feature: FeatureName.ChannelDown, Supported by: Protocol.Companion

    Select previous channel.

  `async def channel_up(self) -> None`
    Feature: FeatureName.ChannelUp, Supported by: Protocol.Companion

    Select next channel.

  `async def down(self, action: InputAction = InputAction.SingleTap) -> None`
    Feature: FeatureName.Down, Supported by: Protocol.Companion, Protocol.DMAP, Protocol.MRP

    Press key down.

  `async def home(self, action: InputAction = InputAction.SingleTap) -> None`
    Feature: FeatureName.Home, Supported by: Protocol.Companion, Protocol.MRP

    Press key home.

  `async def home_hold(self) -> None`
    Feature: FeatureName.HomeHold, Supported by: Protocol.MRP

    Hold key home.

  `async def left(self, action: InputAction = InputAction.SingleTap) -> None`
    Feature: FeatureName.Left, Supported by: Protocol.Companion, Protocol.DMAP, Protocol.MRP

    Press key left.

  `async def menu(self, action: InputAction = InputAction.SingleTap) -> None`
    Feature: FeatureName.Menu, Supported by: Protocol.Companion, Protocol.DMAP, Protocol.MRP

    Press key menu.

  `async def next(self) -> None`
    Feature: FeatureName.Next, Supported by: Protocol.Companion, Protocol.DMAP, Protocol.MRP

    Press key next.

  `async def pause(self) -> None`
    Feature: FeatureName.Pause, Supported by: Protocol.Companion, Protocol.DMAP, Protocol.MRP, Protocol.RAOP

    Press key pause.

  `async def play(self) -> None`
    Feature: FeatureName.Play, Supported by: Protocol.Companion, Protocol.DMAP, Protocol.MRP

    Press key play.

  `async def play_pause(self) -> None`
    Feature: FeatureName.PlayPause, Supported by: Protocol.Companion, Protocol.DMAP, Protocol.MRP

    Toggle between play and pause.

  `async def previous(self) -> None`
    Feature: FeatureName.Previous, Supported by: Protocol.Companion, Protocol.DMAP, Protocol.MRP

    Press key previous.

  `async def right(self, action: InputAction = InputAction.SingleTap) -> None`
    Feature: FeatureName.Right, Supported by: Protocol.Companion, Protocol.DMAP, Protocol.MRP

    Press key right.

  `async def screensaver(self) -> None`
    Feature: FeatureName.Screensaver, Supported by: Protocol.Companion

    Activate screen saver..

  `async def select(self, action: InputAction = InputAction.SingleTap) -> None`
    Feature: FeatureName.Select, Supported by: Protocol.Companion, Protocol.DMAP, Protocol.MRP

    Press key select.

  `async def set_position(self, pos: int) -> None`
    Feature: FeatureName.SetPosition, Supported by: Protocol.DMAP, Protocol.MRP

    Seek in the current playing media.

  `async def set_repeat(self, repeat_state: RepeatState) -> None`
    Feature: FeatureName.SetRepeat, Supported by: Protocol.DMAP, Protocol.MRP

    Change repeat state.

  `async def set_shuffle(self, shuffle_state: ShuffleState) -> None`
    Feature: FeatureName.SetShuffle, Supported by: Protocol.DMAP, Protocol.MRP

    Change shuffle mode to on or off.

  `async def skip_backward(self, time_interval: float = 0.0) -> None`
    Feature: FeatureName.SkipBackward, Supported by: Protocol.Companion, Protocol.DMAP, Protocol.MRP

    Skip backward a time interval.

    If time_interval is not positive or not present, a default or app-chosen time interval is used, which is typically 10, 15, 30, etc. seconds.

  `async def skip_forward(self, time_interval: float = 0.0) -> None`
    Feature: FeatureName.SkipForward, Supported by: Protocol.Companion, Protocol.DMAP, Protocol.MRP

    Skip forward a time interval.

    If time_interval is not positive or not present, a default or app-chosen time interval is used, which is typically 10, 15, 30, etc. seconds.

  `async def stop(self) -> None`
    Feature: FeatureName.Stop, Supported by: Protocol.AirPlay, Protocol.DMAP, Protocol.MRP, Protocol.RAOP

    Press key stop.

  `async def suspend(self) -> None`
    Feature: FeatureName.Suspend, Supported by: Protocol.MRP

    Suspend the device.

    DEPRECATED: Use `Power.turn_off()` instead.

  `async def top_menu(self) -> None`
    Feature: FeatureName.TopMenu, Supported by: Protocol.DMAP, Protocol.MRP

    Go to main menu (long press menu).

  `async def up(self, action: InputAction = InputAction.SingleTap) -> None`
    Feature: FeatureName.Up, Supported by: Protocol.Companion, Protocol.DMAP, Protocol.MRP

    Press key up.

  `async def volume_down(self) -> None`
    Feature: FeatureName.VolumeDown, Supported by: Protocol.Companion, Protocol.DMAP, Protocol.MRP, Protocol.RAOP

    Press key volume down.

    DEPRECATED: Use `Audio.volume_down()` instead.

  `async def volume_up(self) -> None`
    Feature: FeatureName.VolumeUp, Supported by: Protocol.Companion, Protocol.DMAP, Protocol.MRP, Protocol.RAOP

    Press key volume up.

    DEPRECATED: Use `Audio.volume_up()` instead.

  `async def wakeup(self) -> None`
    Feature: FeatureName.WakeUp, Supported by: Protocol.MRP

    Wake up the device.

    DEPRECATED: Use `Power.turn_on()` instead.

`class Storage`

  Base class for storage modules.

  Browse git

  ### Ancestors

  - abc.ABC

  ### Subclasses

  - AbstractStorage

  ### Instance variables

  `var settings -> Sequence[Settings]`

    Return settings for all devices.

  ### Methods

  `async def get_settings(self, config: BaseConfig) -> Settings`

    Return settings for a specific configuration (device).

    The returned Settings object is a reference to an object in the storage module. Changes made can/will be written back to the storage in case "save" is called.

    If no settings exists for the current configuration, new settings are created automatically and returned. If the configuration does not contain any valid identitiers, DeviceIdMissingError will be raised.

  `async def load(self) -> None`

    Load settings from active storage.

  `async def remove_settings(self, settings: Settings) -> bool`

    Remove settings from storage.

    Returns True if settings were removed, otherwise False.

  `async def save(self) -> None`

    Save settings to active storage.

  `async def update_settings(self, config: BaseConfig) -> None`

    Update settings based on config.

    This method extracts settings from a configuration and writes them back to the storage.

`class Stream`

  Base class for stream functionality.

  Browse git

  ### Subclasses

  - pyatv.core.facade.FacadeStream
  - pyatv.protocols.airplay.AirPlayStream
  - pyatv.protocols.raop.RaopStream

  ### Methods

  `def close(self) -> None`

    Close connection and release allocated resources.

  `async def play_url(self, url: str, **kwargs) -> None`
    Feature: FeatureName.PlayUrl, Supported by: Protocol.AirPlay

    Play media from an URL on the device.

  `async def stream_file(self, file: Union[str, io.BufferedIOBase, asyncio.streams.StreamReader], /, metadata: Optional[MediaMetadata] = None, override_missing_metadata: bool = False, **kwargs) -> None`
    Feature: FeatureName.StreamFile, Supported by: Protocol.RAOP

    Stream local or remote file to device.

    Supports either local file paths or a HTTP(s) address.

    INCUBATING METHOD - MIGHT CHANGE IN THE FUTURE!

`class TouchGestures`

  Base class for touch gestures.

  Browse git

  ### Ancestors

  - abc.ABC

  ### Subclasses

  - pyatv.core.facade.FacadeTouchGestures
  - pyatv.protocols.companion.CompanionTouchGestures

  ### Methods

  `async def action(self, x: int, y: int, mode: TouchAction) -> None`
    Feature: FeatureName.TouchAction, Supported by: Protocol.Companion

    Generate a touch event to x,y coordinates (in range [0,1000]).

    :param x: x coordinate :param y: y coordinate :param mode: touch mode (1: press, 3: hold, 4: release)

  `async def click(self, action: InputAction)`
    Feature: FeatureName.TouchClick, Supported by: Protocol.Companion

    Send a touch click.

    :param action: action mode single tap (0), double tap (1), or hold (2)

  `async def swipe(self, start_x: int, start_y: int, end_x: int, end_y: int, duration_ms: int) -> None`
    Feature: FeatureName.Swipe, Supported by: Protocol.Companion

    Generate a swipe gesture.

    From start to end x,y coordinates (in range [0,1000]) in a given time (in milliseconds).

    :param start_x: Start x coordinate :param start_y: Start y coordinate :param end_x: End x coordinate :param end_y: Endi x coordinate :param duration_ms: Time in milliseconds to reach the end coordinates

`class UserAccount (name: str, identifier: str)`

  Information about a user account.

  Initialize a new UserAccount instance.

  Browse git

  ### Instance variables

  `var identifier -> str`

    Return a unique id for the account.

  `var name -> Optional[str]`

    User name.

`class UserAccounts`

  Base class for account handling.

  Browse git

  ### Subclasses

  - pyatv.core.facade.FacadeUserAccounts
  - pyatv.protocols.companion.CompanionUserAccounts

  ### Methods

  `async def account_list(self) -> List[UserAccount]`
    Feature: FeatureName.AccountList, Supported by: Protocol.Companion

    Fetch a list of user accounts that can be switched.

  `async def switch_account(self, account_id: str) -> None`
    Feature: FeatureName.SwitchAccount, Supported by: Protocol.Companion

    Switch user account by account ID.