mopidy.backend
— Backend API
The backend API is the interface that must be implemented when you create a backend. If you are working on a frontend and need to access the backends, see the mopidy.core — Core API instead.
URIs and routing of requests to the backend
When Mopidy’s core layer is processing a client request, it routes the request
to one or more appropriate backends based on the URIs of the objects the
request touches on. The objects’ URIs are compared with the backends’
uri_schemes
to select the relevant backends.
An often used pattern when implementing Mopidy backends is to create your own URI scheme which you use for all tracks, playlists, etc. related to your backend. In most cases the Mopidy URI is translated to an actual URI that GStreamer knows how to play right before playback. For example:
Spotify already has its own URI scheme (
spotify:track:...
,spotify:playlist:...
, etc.) used throughout their applications, and thus Mopidy-Spotify simply uses the same URI scheme.Mopidy-SoundCloud created it’s own URI scheme, after the model of Spotify, and uses URIs of the following forms:
soundcloud:search
,soundcloud:user-...
,soundcloud:exp-...
, andsoundcloud:set-...
. Playback is handled by converting the customsoundcloud:..
URIs tohttp://
URIs immediately before they are passed on to GStreamer for playback.Mopidy differentiates between
file://...
URIs handled by Mopidy-Stream andlocal:...
URIs handled by Mopidy-Local. Mopidy-Stream can playfile://...
URIs pointing to tracks and playlists located anywhere on your system, but it doesn’t know a thing about the object before you play it. On the other hand, Mopidy-Local scans a predefinedlocal/media_dir
to build a meta data library of all known tracks. It is thus limited to playing tracks residing in the media library, but can provide additional features like directory browsing and search. In other words, we have two different ways of playing local music, handled by two different backends, and have thus created two different URI schemes to separate their handling. Thelocal:...
URIs are converted tofile://...
URIs immediately before they are passed on to GStreamer for playback.
If there isn’t an existing URI scheme that fits for your backend’s purpose,
you should create your own, and name it after your extension’s
ext_name
. Care should be taken not to conflict
with already in use URI schemes. It is also recommended to design the format
such that tracks, playlists and other entities can be distinguished easily.
However, it’s important to note that outside of the backend that created them, URIs are opaque values that neither Mopidy’s core layer or Mopidy frontends should attempt to derive any meaning from. The only valid exception to this is checking the scheme.
Backend class
- class mopidy.backend.Backend[source]
Backend API.
If the backend has problems during initialization it should raise
mopidy.exceptions.BackendError
with a descriptive error message. This will make Mopidy print the error message and exit so that the user can fix the issue.- Parameters:
config – the entire Mopidy configuration
audio – actor proxy for the audio subsystem
- audio: AudioProxy
Actor proxy to an instance of
mopidy.audio.Audio
.Should be passed to the backend constructor as the kwarg
audio
, which will then set this field.
- library: LibraryProvider | None = None
The library provider. An instance of
LibraryProvider
, orNone
if the backend doesn’t provide a library.
-
playback:
PlaybackProvider
|None
= None The playback provider. An instance of
PlaybackProvider
, orNone
if the backend doesn’t provide playback.
-
playlists:
PlaylistsProvider
|None
= None The playlists provider. An instance of
PlaylistsProvider
, or class:None if the backend doesn’t provide playlists.
Playback provider
- class mopidy.backend.PlaybackProvider(audio, backend) None [source]
A playback provider provides audio playback control.
- Parameters:
audio (
AudioProxy
) – the audio actorbackend (
Backend
) – the backend
- change_track(track) bool [source]
Switch to provided track.
MAY be reimplemented by subclass.
It is unlikely it makes sense for any backends to override this. For most practical purposes it should be considered an internal call between backends and core that backend authors should not touch.
The default implementation will call
translate_uri()
which is what you want to implement.
- get_time_position() DurationMs [source]
Get the current time position in milliseconds.
MAY be reimplemented by subclass.
- is_live(uri) bool [source]
Decide if the URI should be treated as a live stream or not.
MAY be reimplemented by subclass.
Playing a source as a live stream disables buffering, which reduces latency before playback starts, and discards data when paused.
- on_source_setup(source) None [source]
Called when a new GStreamer source is created, allowing us to configure the source. This runs in the audio thread so should not block.
MAY be reimplemented by subclass.
- Parameters:
source (
Element
) – the GStreamer source element- Return type:
New in version 3.4.
- pause() bool [source]
Pause playback.
MAY be reimplemented by subclass.
Returns
True
if successful, elseFalse
.- Return type:
- play() bool [source]
Start playback.
MAY be reimplemented by subclass.
Returns
True
if successful, elseFalse
.- Return type:
- prepare_change() None [source]
Indicate that an URI change is about to happen.
MAY be reimplemented by subclass.
It is extremely unlikely it makes sense for any backends to override this. For most practical purposes it should be considered an internal call between backends and core that backend authors should not touch.
- Return type:
- resume() bool [source]
Resume playback at the same time position playback was paused.
MAY be reimplemented by subclass.
Returns
True
if successful, elseFalse
.- Return type:
- seek(time_position) bool [source]
Seek to a given time position.
MAY be reimplemented by subclass.
Returns
True
if successful, elseFalse
.
- should_download(uri) bool [source]
Attempt progressive download buffering for the URI or not.
MAY be reimplemented by subclass.
When streaming a fixed length file, the entire file can be buffered to improve playback performance.
- stop() bool [source]
Stop playback.
MAY be reimplemented by subclass.
Should not be used for tracking if tracks have been played or when we are done playing them.
Returns
True
if successful, elseFalse
.- Return type:
- translate_uri(uri) Uri | None [source]
Convert custom URI scheme to real playable URI.
MAY be reimplemented by subclass.
This is very likely the only thing you need to override as a backend author. Typically this is where you convert any Mopidy specific URI to a real URI and then return it. If you can’t convert the URI just return
None
.
Playlists provider
- class mopidy.backend.PlaylistsProvider(backend) None [source]
A playlist provider exposes a collection of playlists.
The methods can create/change/delete playlists in this collection, and lookup of any playlist the backend knows about.
- Parameters:
backend (
Backend
) – backend the controller is a part of
- as_list() list[Ref] [source]
Get a list of the currently available playlists.
Returns a list of
Ref
objects referring to the playlists. In other words, no information about the playlists’ content is given. :rtype:list
[Ref
]New in version 1.0.
- create(name) Playlist | None [source]
Create a new empty playlist with the given name.
Returns a new playlist with the given name and an URI, or
None
on failure.MUST be implemented by subclass.
- delete(uri) bool [source]
Delete playlist identified by the URI.
Returns
True
if deleted,False
otherwise.MUST be implemented by subclass.
Changed in version 2.2: Return type defined.
- get_items(uri) list[Ref] | None [source]
Get the items in a playlist specified by
uri
.Returns a list of
Ref
objects referring to the playlist’s items.If a playlist with the given
uri
doesn’t exist, it returnsNone
. :rtype:list
[Ref
] |None
New in version 1.0.
- lookup(uri) Playlist | None [source]
Lookup playlist with given URI in both the set of playlists and in any other playlist source.
Returns the playlists or
None
if not found.MUST be implemented by subclass.
- refresh() None [source]
Refresh the playlists in
playlists
.MUST be implemented by subclass.
- Return type:
Library provider
- class mopidy.backend.LibraryProvider(backend) None [source]
A library provider provides a library of music to Mopidy.
- Parameters:
backend (
Backend
) – backend the controller is a part of
- browse(uri) list[Ref] [source]
See
mopidy.core.LibraryController.browse()
.If you implement this method, make sure to also set
root_directory
.MAY be implemented by subclass.
- get_distinct(field, query=None) set[str] [source]
See
mopidy.core.LibraryController.get_distinct()
.MAY be implemented by subclass.
Default implementation will simply return an empty set.
Note that backends should always return an empty set for unexpected field types.
- get_images(uris) dict[Uri, list[Image]] [source]
See
mopidy.core.LibraryController.get_images()
.MAY be implemented by subclass.
Default implementation will simply return an empty dictionary.
- lookup(uri) list[Track] [source]
See
mopidy.core.LibraryController.lookup()
.MUST be implemented by subclass if :meth:`lookup_many` is not implemented. :rtype:
list
[Track
]Deprecated since version 4.0: Implement
lookup_many()
instead. Iflookup_many()
is implemented, Mopidy will never call this method on a backend.
- lookup_many(uris) dict[Uri, list[Track]] [source]
See
mopidy.core.LibraryController.lookup()
.MUST be implemented by subclass.
- refresh(uri=None) None [source]
See
mopidy.core.LibraryController.refresh()
.MAY be implemented by subclass.
- Return type:
-
root_directory:
Ref
|None
= None mopidy.models.Ref.directory
instance with a URI and name set representing the root of this library’s browse tree. URIs must use one of the schemes supported by the backend, and name should be set to a human friendly value.MUST be set by any class that implements
LibraryProvider.browse()
.
- search(query, uris=None, exact=False) SearchResult | None [source]
See
mopidy.core.LibraryController.search()
.MAY be implemented by subclass. :rtype:
SearchResult
|None
New in version 1.0: The
exact
param which replaces the oldfind_exact
.
Backend listener
- class mopidy.backend.BackendListener[source]
Marker interface for recipients of events sent by the backend actors.
Any Pykka actor that mixes in this class will receive calls to the methods defined here when the corresponding events happen in a backend actor. This interface is used both for looking up what actors to notify of the events, and for providing default implementations for those listeners that are not interested in all events.
Normally, only the Core actor should mix in this class.
Backend implementations
See the extension registry.