mirror of
https://github.com/clementine-player/Clementine
synced 2024-12-16 11:19:18 +01:00
230 lines
7.1 KiB
Python
230 lines
7.1 KiB
Python
import clementine
|
|
|
|
import PythonQt
|
|
from PythonQt.QtCore import QSettings, QUrl
|
|
from PythonQt.QtGui import QAction, QDesktopServices, QIcon, QMenu, \
|
|
QStandardItem
|
|
from PythonQt.QtNetwork import QNetworkRequest
|
|
|
|
import json
|
|
import logging
|
|
import operator
|
|
import os.path
|
|
|
|
LOGGER = logging.getLogger("di.servicebase")
|
|
|
|
|
|
class DigitallyImportedUrlHandler(clementine.UrlHandler):
|
|
def __init__(self, url_scheme, service):
|
|
clementine.UrlHandler.__init__(self, service)
|
|
self.url_scheme = url_scheme
|
|
self.service = service
|
|
|
|
self.last_original_url = None
|
|
self.task_id = None
|
|
|
|
def scheme(self):
|
|
return self.url_scheme
|
|
|
|
def StartLoading(self, original_url):
|
|
result = clementine.UrlHandler_LoadResult()
|
|
|
|
if self.task_id is not None:
|
|
return result
|
|
if self.service.PLAYLISTS[self.service.audio_type]["premium"] and \
|
|
(len(self.service.username) == 0 or len(self.service.password) == 0):
|
|
self.service.StreamError(self.tr("You have selected a Premium-only audio type but do not have any account details entered"))
|
|
return result
|
|
|
|
key = original_url.host()
|
|
LOGGER.info("Loading station %s", key)
|
|
self.service.LoadStation(key)
|
|
|
|
# Save the original URL so we can emit it in the finished signal later
|
|
self.last_original_url = original_url
|
|
|
|
# Tell the user what's happening
|
|
self.task_id = clementine.task_manager.StartTask(self.tr("Loading stream"))
|
|
|
|
result.type_ = clementine.UrlHandler_LoadResult.WillLoadAsynchronously
|
|
result.original_url_ = original_url
|
|
return result
|
|
|
|
def LoadPlaylistFinished(self, reply):
|
|
reply.deleteLater()
|
|
|
|
if self.task_id is None:
|
|
return
|
|
|
|
# Stop the spinner in the status bar
|
|
clementine.task_manager.SetTaskFinished(self.task_id)
|
|
self.task_id = None
|
|
|
|
# Try to parse the playlist
|
|
parser = clementine.PlaylistParser(clementine.library)
|
|
songs = parser.LoadFromDevice(reply)
|
|
|
|
LOGGER.info("Loading station finished, got %d songs", len(songs))
|
|
|
|
# Failed to get the playlist?
|
|
if len(songs) == 0:
|
|
self.service.StreamError("Error loading playlist '%s'" % reply.url().toString())
|
|
return
|
|
|
|
result = clementine.UrlHandler_LoadResult()
|
|
result.original_url_ = self.last_original_url
|
|
|
|
# Take the first track in the playlist
|
|
result.type_ = clementine.UrlHandler_LoadResult.TrackAvailable
|
|
result.media_url_ = songs[0].url()
|
|
|
|
self.AsyncLoadComplete(result)
|
|
|
|
|
|
class DigitallyImportedServiceBase(clementine.RadioService):
|
|
# Set these in subclasses
|
|
HOMEPAGE_URL = None
|
|
HOMEPAGE_NAME = None
|
|
STREAM_LIST_URL = None
|
|
ICON_FILENAME = None
|
|
SERVICE_NAME = None
|
|
SERVICE_DESCRIPTION = None
|
|
PLAYLISTS = []
|
|
URL_SCHEME = None
|
|
|
|
SETTINGS_GROUP = "digitally_imported"
|
|
|
|
def Init(self, model, settings_dialog_callback):
|
|
clementine.RadioService.__init__(self, self.SERVICE_NAME, model)
|
|
|
|
self.settings_dialog_callback = settings_dialog_callback
|
|
|
|
self.url_handler = DigitallyImportedUrlHandler(self.URL_SCHEME, self)
|
|
clementine.player.RegisterUrlHandler(self.url_handler)
|
|
|
|
self.network = clementine.NetworkAccessManager(self)
|
|
self.path = os.path.dirname(__file__)
|
|
|
|
self.audio_type = 0
|
|
self.username = ""
|
|
self.password = ""
|
|
|
|
self.context_index = None
|
|
self.menu = None
|
|
self.root = None
|
|
self.task_id = None
|
|
self.refresh_streams_reply = None
|
|
self.load_station_reply = None
|
|
self.items = []
|
|
|
|
self.ReloadSettings()
|
|
|
|
def ReloadSettings(self):
|
|
settings = QSettings()
|
|
settings.beginGroup(self.SETTINGS_GROUP)
|
|
|
|
self.audio_type = int(settings.value("audio_type", 0))
|
|
self.username = unicode(settings.value("username", ""))
|
|
self.password = unicode(settings.value("password", ""))
|
|
|
|
def CreateRootItem(self):
|
|
self.root = QStandardItem(QIcon(os.path.join(self.path, self.ICON_FILENAME)),
|
|
self.SERVICE_DESCRIPTION)
|
|
self.root.setData(True, clementine.RadioModel.Role_CanLazyLoad)
|
|
return self.root
|
|
|
|
def LazyPopulate(self, parent):
|
|
if parent == self.root:
|
|
# Download the list of streams the first time the user expands the root
|
|
self.RefreshStreams()
|
|
|
|
def ShowContextMenu(self, index, global_pos):
|
|
if not self.menu:
|
|
self.menu = QMenu()
|
|
|
|
for action in self.GetPlaylistActions():
|
|
self.menu.addAction(action)
|
|
self.menu.addAction(clementine.IconLoader.Load("download"),
|
|
self.tr("Open " + self.HOMEPAGE_NAME + " in browser"), self.Homepage)
|
|
self.menu.addAction(clementine.IconLoader.Load("view-refresh"),
|
|
self.tr("Refresh streams"), self.RefreshStreams)
|
|
|
|
self.menu.addSeparator()
|
|
|
|
self.menu.addAction(clementine.IconLoader.Load("configure"),
|
|
self.tr("Configure..."), self.settings_dialog_callback())
|
|
|
|
self.context_index = index
|
|
self.menu.popup(global_pos)
|
|
|
|
def GetCurrentIndex(self):
|
|
return self.context_index
|
|
|
|
def Homepage(self):
|
|
QDesktopServices.openUrl(self.HOMEPAGE_URL)
|
|
|
|
def RefreshStreams(self):
|
|
if self.task_id is not None:
|
|
return
|
|
|
|
LOGGER.info("Getting stream list from '%s'", self.STREAM_LIST_URL)
|
|
|
|
# Request the list of stations
|
|
self.refresh_streams_reply = self.network.get(QNetworkRequest(self.STREAM_LIST_URL))
|
|
self.refresh_streams_reply.connect("finished()", self.RefreshStreamsFinished)
|
|
|
|
# Give the user some indication that we're doing something
|
|
self.task_id = clementine.task_manager.StartTask(self.tr("Getting streams"))
|
|
|
|
def RefreshStreamsFinished(self):
|
|
if self.refresh_streams_reply is None:
|
|
return
|
|
|
|
reply = self.refresh_streams_reply
|
|
reply.deleteLater()
|
|
|
|
if self.task_id is None:
|
|
return
|
|
|
|
# Stop the spinner in the status bar
|
|
clementine.task_manager.SetTaskFinished(self.task_id)
|
|
self.task_id = None
|
|
|
|
# Read the data and parse the json object inside
|
|
json_data = reply.readAll().data()
|
|
streams = json.loads(json_data)
|
|
|
|
# Sort by name
|
|
streams = sorted(streams, key=operator.itemgetter("name"))
|
|
|
|
LOGGER.info("Loaded %d streams", len(streams))
|
|
|
|
# Now we have the list of streams, so clear any existing items in the list
|
|
# and insert the new ones
|
|
if self.root.hasChildren():
|
|
self.root.removeRows(0, self.root.rowCount())
|
|
|
|
for stream in streams:
|
|
song = clementine.Song()
|
|
song.set_title(stream["name"])
|
|
song.set_artist(self.SERVICE_DESCRIPTION)
|
|
song.set_url(QUrl("%s://%s" % (self.URL_SCHEME, stream["key"])))
|
|
|
|
item = QStandardItem(QIcon(":last.fm/icon_radio.png"), stream["name"])
|
|
item.setData(stream["description"], PythonQt.QtCore.Qt.ToolTipRole)
|
|
item.setData(clementine.RadioModel.PlayBehaviour_SingleItem, clementine.RadioModel.Role_PlayBehaviour)
|
|
item.setData(song, clementine.RadioModel.Role_SongMetadata)
|
|
self.root.appendRow(item)
|
|
|
|
# Keep references to the items otherwise Python will delete them
|
|
self.items.append(item)
|
|
|
|
def playlistitem_options(self):
|
|
return clementine.PlaylistItem.Options(clementine.PlaylistItem.PauseDisabled)
|
|
|
|
def LoadStation(self, key):
|
|
raise NotImplementedError()
|
|
|
|
def LoadPlaylistFinished(self):
|
|
self.url_handler.LoadPlaylistFinished(self.load_station_reply)
|