def __init__(self, *args, **kwargs):
Connection.__init__(self, *args, **kwargs)
self._client = Gio.SocketClient.new()
self._client.set_timeout(7)
if self._address.proxy is not None:
self._proxy_resolver = self._address.proxy.get_resolver()
self._client.set_proxy_resolver(self._proxy_resolver)
GObject.Object.connect(self._client, 'event', self._on_event)
self._con = None
self._read_buffer = b''
self._write_queue = deque([])
self._write_stanza_buffer = None
self._connect_cancellable = Gio.Cancellable()
self._read_cancellable = Gio.Cancellable()
self._tls_handshake_in_progress = False
self._input_closed = False
self._output_closed = False
self._keepalive_id = None
def __init__(self, initial_search, view_type):
"""
Init Popover
@param initial_search as str
"""
View.__init__(
self, StorageType.COLLECTION | StorageType.SAVED
| StorageType.SEARCH | StorageType.EPHEMERAL
| StorageType.SPOTIFY_NEW_RELEASES | StorageType.SPOTIFY_SIMILARS,
ViewType.SEARCH | ViewType.SCROLLED | ViewType.OVERLAY)
Gtk.Bin.__init__(self)
self.__timeout_id = None
self.__current_search = ""
self.__search = Search()
self.__search.set_web_search(
App().settings.get_value("web-search").get_string())
self.__cancellable = Gio.Cancellable()
self._empty_message = _("Search for artists, albums and tracks")
self._empty_icon_name = "edit-find-symbolic"
self.__cancellable = Gio.Cancellable()
self.__banner = SearchBannerWidget()
self.__banner.show()
self.__stack = SearchStack(self.storage_type)
self.__stack.show()
self.add_widget(self.__stack, self.__banner)
self.__banner.entry.connect("changed", self._on_search_changed)
self.show_placeholder(True, _("Search for artists, albums and tracks"))
self.set_search(initial_search)
return [(self.__search, "match-artist", "_on_match_artist"),
(self.__search, "match-album", "_on_match_album"),
(self.__search, "match-track", "_on_match_track"),
(self.__search, "finished", "_on_search_finished"),
(App().settings, "changed::web-search",
"_on_web_search_changed")]
def __init__(self):
"""
Init player
"""
self.__next_cancellable = Gio.Cancellable()
self.__radio_cancellable = Gio.Cancellable()
self.connect("next-changed", self.__on_next_changed)
def start(self):
self.start_time = time.time()
if not self.remote.query_exists(Gio.Cancellable()):
logger.debug("Mounting remote volume")
self.remote.mount_enclosing_volume(Gio.MountMountFlags.NONE,
Gtk.MountOperation(),
Gio.Cancellable(),
self.mount_cb,
None)
else:
logger.debug("Scheduling download")
Gdk.threads_add_idle(GLib.PRIORITY_DEFAULT,
self.schedule_download, None)
def __init__(self, command):
Gtk.Window.__init__(
self,
title="Log Interface",
default_width=500,
default_height=400,
)
self.cancellable = Gio.Cancellable()
self.start_button = Gtk.Button(label="Show log")
self.start_button.connect("clicked", self.on_start_clicked)
textview = Gtk.TextView()
self.textbuffer = textview.get_buffer()
scrolled = Gtk.ScrolledWindow()
scrolled.add(textview)
self.command = command
progress = Gtk.ProgressBar(show_text=True)
box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL,
spacing=6,
border_width=12)
box.pack_start(self.start_button, False, True, 0)
box.pack_start(progress, False, True, 0)
box.pack_start(scrolled, True, True, 0)
self.add(box)
def __init__(self, uri, page_id, window):
"""
Init popover
@param uri as str
@param page_id as int
@param window as Window
"""
Gtk.Popover.__init__(self)
self.set_modal(False)
window.register(self)
self.__cache_uris = []
self.__uri = uri
self.__page_id = page_id
self.__cancellable = Gio.Cancellable()
self.__filter = ""
builder = Gtk.Builder()
builder.add_from_resource("/org/gnome/Eolie/PopoverImages.ui")
builder.connect_signals(self)
widget = builder.get_object("widget")
self.__spinner = builder.get_object("spinner")
self.__flowbox = builder.get_object("flowbox")
self.__flowbox.set_filter_func(self.__filter_func)
self.__entry = builder.get_object("entry")
self.__button = builder.get_object("button")
self.add(widget)
if Gio.NetworkMonitor.get_default().get_network_available():
El().helper.call("GetImages", page_id, None, self.__on_get_images)
(width, height) = El().active_window.get_size()
self.set_size_request(width / 2, height / 1.5)
self.connect("closed", self.__on_closed)
self.__task_helper = TaskHelper()
def _load_profile_location(self, location, recursive, toplevel=False):
try:
info = location.query_info("standard::*",
Gio.FileQueryInfoFlags.NONE, None)
except GLib.Error as e:
self._warning("Failed to load location %s: %s", location.get_uri(),
str(e.args))
return
if info.get_file_type() == Gio.FileType.DIRECTORY:
if recursive or toplevel:
monitor = location.monitor_directory(Gio.FileMonitorFlags.NONE,
Gio.Cancellable())
self._debug("Adding %s as directory to watch",
location.get_uri())
monitor.connect("changed", self._files_changed)
self._monitors.append(monitor)
self._debug("Descending into %s to find wallpapers",
location.get_uri())
self._load_profile_children(location, recursive)
elif info.get_file_type(
) == Gio.FileType.REGULAR and info.get_content_type(
) in self._accepted:
self._debug("Adding wallpaper %s", location.get_uri())
self._wallpapers.append(location.get_uri())
def on_scene_called(self):
"""
Fired when the scene has been called.
"""
# Locked
self.unlockbar.emit("locked")
# Enter in the bus
self.bus_cancellable = Gio.Cancellable()
self.bus = Gio.bus_get_sync(Gio.BusType.SYSTEM, self.bus_cancellable)
self.VeraPowerManager = Gio.DBusProxy.new_sync(
self.bus, 0, None, BUS_NAME,
"/org/semplicelinux/vera/powermanager", BUS_NAME,
self.bus_cancellable)
# connect signals
self.VeraPowerManager.connect(
"g-signal",
lambda proxy, sender, signal, params: self.signal_handlers[signal]
(params) if signal in self.signal_handlers else None)
# Check for backlight support
if self.VeraPowerManager.IsBacklightSupported():
self.objects.display_frame.show()
self.on_brightness_level_changed_external()
else:
self.objects.display_frame.hide()
# Update comboboxes
self.building = True
self.objects.power_button_action.set_active(
ACTIONS.index(self.VeraPowerManager.GetHandlePowerKey()))
self.objects.lid_switch_action.set_active(
ACTIONS.index(self.VeraPowerManager.GetHandleLidSwitch()))
self.building = False
def get_icon(f):
file = Gio.File.new_for_path("/")
folder_info = file.query_info('standard::icon', 0, Gio.Cancellable())
folder_icon = folder_info.get_icon().get_names()[0]
icon_theme = Gtk.IconTheme.get_default()
icon_folder = icon_theme.lookup_icon(folder_icon, 128, 0)
if icon_folder:
folder_icon = icon_folder.get_filename()
else:
folder_icon = "images/folder.png"
if os.path.isdir(f):
icon = folder_icon
else:
type_, encoding = mimetypes.guess_type(f)
if type_:
file_icon = Gio.content_type_get_icon(type_)
file_info = icon_theme.choose_icon(file_icon.get_names(), 128, 0)
if file_info:
icon = file_info.get_filename()
else:
icon = "images/file.png"
else:
icon = "images/file.png"
return icon
def _load_uri(self, uri, recursive, top_level=False):
try:
location = Gio.File.new_for_uri(uri)
info = location.query_info('standard::*',
Gio.FileQueryInfoFlags.NONE, None)
except GLib.Error as e:
logger.warning('failed to load location %s: %s', uri, str(e.args))
return
if info.get_file_type() == Gio.FileType.DIRECTORY and (recursive
or top_level):
monitor = location.monitor_directory(Gio.FileMonitorFlags.NONE,
Gio.Cancellable())
logger.debug('adding %s as directory to watch', location.get_uri())
monitor.connect('changed', self._files_changed)
self._monitors.append(monitor)
logger.debug('descending into %s to find wallpapers',
location.get_uri())
self._load_children(location, recursive)
elif info.get_file_type(
) == Gio.FileType.REGULAR and info.get_content_type() in ACCEPTED:
logger.debug('adding wallpaper %s', location.get_uri())
if location.get_uri() in self._wallpapers:
logger.warning('%s already loaded, skipping duplicate',
location.get_uri())
return
self._wallpapers.append(location.get_uri())
def __init__(self):
"""
Init playbin
"""
# In the case of gapless playback, both 'about-to-finish'
# and 'eos' can occur during the same stream.
self.__track_in_pipe = False
self.__cancellable = Gio.Cancellable()
self.__codecs = Codecs()
self._current_track = Track()
self._next_track = Track()
self._prev_track = Track()
self._playbin = self._playbin1 = Gst.ElementFactory.make(
"playbin", "player")
self._playbin2 = Gst.ElementFactory.make("playbin", "player")
self._plugins = self._plugins1 = PluginsPlayer(self._playbin1)
self._plugins2 = PluginsPlayer(self._playbin2)
for playbin in [self._playbin1, self._playbin2]:
flags = playbin.get_property("flags")
flags &= ~GstPlayFlags.GST_PLAY_FLAG_VIDEO
playbin.set_property("flags", flags)
playbin.set_property("buffer-size", 5 << 20)
playbin.set_property("buffer-duration", 10 * Gst.SECOND)
playbin.connect("notify::volume", self.__on_volume_changed)
playbin.connect("about-to-finish", self._on_stream_about_to_finish)
bus = playbin.get_bus()
bus.add_signal_watch()
bus.connect("message::error", self._on_bus_error)
bus.connect("message::eos", self._on_bus_eos)
bus.connect("message::element", self._on_bus_element)
bus.connect("message::stream-start", self._on_stream_start)
bus.connect("message::tag", self._on_bus_message_tag)
self._start_time = 0
def __init__(self):
super(DownloadWindow, self).__init__(default_width=500,
default_height=400,
title="Async I/O Example")
self.cancellable = Gio.Cancellable()
self.cancel_button = Gtk.Button(label="Cancel")
self.cancel_button.connect("clicked", self.on_cancel_clicked)
self.cancel_button.set_sensitive(False)
self.start_button = Gtk.Button(label="Load")
self.start_button.connect("clicked", self.on_start_clicked)
textview = Gtk.TextView()
self.textbuffer = textview.get_buffer()
scrolled = Gtk.ScrolledWindow()
scrolled.add(textview)
box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL,
spacing=6,
border_width=12)
box.pack_start(self.start_button, False, True, 0)
box.pack_start(self.cancel_button, False, True, 0)
box.pack_start(scrolled, True, True, 0)
self.add(box)
def __init__(self, artist_id):
"""
Init popover
@param artist_id as int
"""
Gtk.Bin.__init__(self)
(path, env) = get_youtube_dl()
self.__show_all = path is not None
self.__added = []
self.__artist_id = artist_id
self.__cancellable = Gio.Cancellable()
self.connect("map", self.__on_map)
self.connect("unmap", self.__on_unmap)
self.__stack = Gtk.Stack.new()
self.__stack.show()
self.__stack.set_transition_type(Gtk.StackTransitionType.CROSSFADE)
self.__stack.set_transition_duration(200)
self.__label = Gtk.Label.new(_("Loading…"))
self.__label.get_style_context().add_class("bold")
self.__label.get_style_context().add_class("dim-label")
self.__label.show()
self.__listbox = Gtk.ListBox()
self.__listbox.get_style_context().add_class("trackswidget")
self.__listbox.set_vexpand(True)
self.__listbox.set_selection_mode(Gtk.SelectionMode.NONE)
self.__listbox.set_activate_on_single_click(True)
self.__listbox.connect("row-activated", self.__on_row_activated)
self.__listbox.set_sort_func(self.__sort_func)
self.__listbox.show()
self.__stack.add(self.__label)
self.__stack.add(self.__listbox)
self.add(self.__stack)
self.set_hexpand(True)
def __init__(self):
"""
Init popover
"""
Popover.__init__(self)
self.__lastfm_signal_id = None
self.__spotify_signal_id = None
builder = Gtk.Builder()
builder.add_from_resource("/org/gnome/Lollypop/SimilarsPopover.ui")
self.__show_all = GLib.find_program_in_path("youtube-dl") is not None
self.__added = []
self.__cancellable = Gio.Cancellable()
self.connect("map", self.__on_map)
self.connect("unmap", self.__on_unmap)
self.__stack = builder.get_object("stack")
self.__spinner = builder.get_object("spinner")
self.__spinner.start()
self.__listbox = Gtk.ListBox()
self.__listbox.get_style_context().add_class("trackswidget")
self.__listbox.set_vexpand(True)
self.__listbox.set_selection_mode(Gtk.SelectionMode.NONE)
self.__listbox.set_activate_on_single_click(True)
self.__listbox.connect("row-activated", self.__on_row_activated)
self.__listbox.show()
self.__stack.add(self.__listbox)
self.add(builder.get_object("widget"))
def __populate(self):
"""
Populate searching items
in db based on text entry current text
"""
self.__cancellable = Gio.Cancellable()
self.__button_stack.set_visible_child(self.__spinner)
self.__history = []
if len(self.__current_search) > 2:
self.__spinner.start()
state = self.__search_type_action.get_state().get_string()
current_search = self.__current_search.lower()
if state == "local":
search = Search()
search.get(current_search,
self.__cancellable,
callback=(self.__on_search_get, current_search))
elif state == "web":
App().task_helper.run(App().spotify.search, current_search,
self.__cancellable)
else:
self.__stack.set_visible_child_name("placeholder")
self.__set_default_placeholder()
self.__button_stack.set_visible_child(self.__new_button)
GLib.idle_add(self.__spinner.stop)
def __init__(self, uri, page_id):
"""
Init popover
@param uri as str
@param page_id as int
"""
Gtk.Popover.__init__(self)
self.__uri = uri
self.__page_id = page_id
self.__cancellable = Gio.Cancellable()
self.__filter = ""
builder = Gtk.Builder()
builder.add_from_resource("/org/gnome/Eolie/PopoverImages.ui")
builder.connect_signals(self)
widget = builder.get_object("widget")
self.__spinner = builder.get_object("spinner")
self.__flowbox = builder.get_object("flowbox")
self.__flowbox.set_filter_func(self.__filter_func)
self.__entry = builder.get_object("entry")
self.__button = builder.get_object("button")
self.add(widget)
if Gio.NetworkMonitor.get_default().get_network_available():
helper = DBusHelper()
helper.call("GetImages",
GLib.Variant("(i)", (page_id,)),
self.__on_get_images, None)
(width, height) = El().active_window.get_size()
self.set_size_request(width / 2, height / 1.5)
self.connect("closed", self.__on_closed)
def on_scene_called(self): """ Fired when the scene has been called. """ # Create the OsRelease object self.osrelease = OsRelease() # Enter in the bus self.bus_cancellable = Gio.Cancellable() self.bus = Gio.bus_get_sync(Gio.BusType.SYSTEM, self.bus_cancellable) self.Hostname = Gio.DBusProxy.new_sync( self.bus, 0, None, BUS_NAME, "/org/freedesktop/hostname1", BUS_NAME, self.bus_cancellable ) self.HostnameProperties = Gio.DBusProxy.new_sync( self.bus, 0, None, BUS_NAME, "/org/freedesktop/hostname1", "org.freedesktop.DBus.Properties", self.bus_cancellable ) # Really we should create a new proxy to get the properties?! #self.refresh_infos() self.update()
def __on_method_call(
self,
connection,
sender,
object_path,
interface_name,
method_name,
parameters,
invocation,
):
method_fname = self.__fname(interface_name, method_name)
method_info = self.__methods[method_fname]
args = list(parameters.unpack())
context = DBusMethodCallContext(connection, sender, object_path,
method_info)
job = DBusMethodCallJob(self.application, method_info, args,
invocation, context)
cancellable = Gio.Cancellable()
old_job = self.__method_calls.pop(method_name, None)
if old_job:
old_job.cancel()
self.__method_calls[method_name] = cancellable
Gio.io_scheduler_push_job(job.run_async, None, GLib.PRIORITY_DEFAULT,
cancellable)
def __on_unmap(self, widget):
"""
Cancel drawing
@param widget as Gtk.Widget
"""
self.__cancellable.cancel()
self.__cancellable = Gio.Cancellable()
def __init__(self):
"""
Init Popover
"""
BaseView.__init__(self)
Gtk.Bin.__init__(self)
self.connect("map", self.__on_map)
self.connect("unmap", self.__on_unmap)
self.__timeout_id = None
self.__current_search = ""
self.__cancellable = Gio.Cancellable()
self.__history = []
builder = Gtk.Builder()
builder.add_from_resource("/org/gnome/Lollypop/SearchView.ui")
builder.connect_signals(self)
self.__widget = builder.get_object("widget")
self.__new_button = builder.get_object("new_button")
self.__play_button = builder.get_object("play_button")
self.__entry = builder.get_object("entry")
self.__spinner = builder.get_object("spinner")
self.__header_stack = builder.get_object("header_stack")
self.__stack = builder.get_object("stack")
self.__placeholder = builder.get_object("placeholder")
self.__view = AlbumsListView(RowListType.SEARCH)
self.__view.show()
self.__stack.add_named(self.__view, "view")
self.__set_default_placeholder()
self.add(self.__widget)
def __init__(self):
"""
Init view
"""
View.__init__(self)
InformationController.__init__(
self, False,
ArtBehaviour.BLUR_MAX | ArtBehaviour.CROP | ArtBehaviour.DARKER)
self.__current_changed_id = None
self.__size_allocate_timeout_id = None
self.__lyrics_timeout_id = None
self.__downloads_running = 0
self.__lyrics_text = ""
self.__size = 0
self.__cancellable = Gio.Cancellable()
builder = Gtk.Builder()
builder.add_from_resource("/org/gnome/Lollypop/LyricsView.ui")
builder.connect_signals(self)
self._artwork = builder.get_object("cover")
self.__lyrics_label = LyricsLabel()
self.__lyrics_label.show()
builder.get_object("viewport").add(self.__lyrics_label)
self.__translate_button = builder.get_object("translate_button")
# We do not use View scrolled window because it does not work with
# an overlay
self.add(builder.get_object("widget"))
self.connect("size-allocate", self.__on_size_allocate)
self.__sync_lyrics_helper = SyncLyricsHelper()
def __init__(self, album, height, view_type, reveal, cover_uri, parent):
"""
Init row widgets
@param album as Album
@param height as int
@param view_type as ViewType
@param reveal as bool
@param parent as AlbumListView
"""
Gtk.ListBoxRow.__init__(self)
TracksView.__init__(self, view_type)
if view_type & ViewType.DND:
DNDRow.__init__(self)
self.__next_row = None
self.__previous_row = None
self.__revealer = None
self.__parent = parent
self.__reveal = reveal
self.__cover_uri = cover_uri
self._artwork = None
self._album = album
self.__view_type = view_type
self.__cancellable = Gio.Cancellable()
self.set_sensitive(False)
self.set_property("height-request", height)
self.connect("destroy", self.__on_destroy)
def icon(self, icon_size=16, save=True):
"""
Get file type icon for File
:param icon_size: requested icon size
:param save: True to copy icon to media flder, otherwise will return path where OS stores the icon
:return: full absolute path to File icon or nothing
"""
if platform.system() == 'Linux':
try:
file = Gio.File.new_for_path(self.path)
file_info = file.query_info('standard::icon', 0, Gio.Cancellable())
file_icon = file_info.get_icon().get_names()[0]
icon_theme = Gtk.IconTheme.get_default()
icon_info = icon_theme.lookup_icon(file_icon, icon_size, 0)
icon_path = icon_info.get_filename()
except (NameError, AttributeError):
return ''
if os.path.isfile(icon_path):
if save:
icon_store_path = os.path.join(self.folder_dir_path, 'media', 'fileicons')
if not os.path.isfile(icon_store_path + os.sep + os.path.basename(icon_path)):
try:
os.makedirs(icon_store_path, exist_ok=True)
icon_path = shutil.copy(icon_path, icon_store_path)
icon_path = 'media/fileicons/' + os.path.basename(icon_path)
except OSError:
pass
return icon_path
def __play_radio_common(self):
"""
Emit signal and reset cancellable
"""
emit_signal(self, "loading-changed", True, Track())
self.__radio_cancellable.cancel()
self.__radio_cancellable = Gio.Cancellable()
def gio_copy_in_place(self, file):
"helper that copies the file to the local system via gio"
gio_file = Gio.file_new_for_path(file)
if (gio_file.get_uri_scheme() == "file"):
return file
if (os.getuid()==0):
self.show_alert(Gtk.MessageType.ERROR,
_("Can not download as root"),
_("Remote packages can not be downloaded when "
"running as root. Please try again as a "
"normal user."))
sys.exit(1)
# Download the file
temp_file_name = os.path.join(tempfile.mkdtemp(),os.path.basename(file))
gio_dest = Gio.file_new_for_path(temp_file_name)
try:
# download
gio_cancellable = Gio.Cancellable()
self.button_cancel_download.connect("clicked", self.on_button_cancel_download_clicked, gio_cancellable)
self.dialog_gio_download.set_transient_for(self.window_main)
self.dialog_gio_download.show()
self.label_action.set_text(_("Downloading package"))
if gio_file.copy(gio_dest, 0, gio_cancellable,
self.gio_progress_callback, 0):
file = gio_dest.get_path()
self.dialog_gio_download.hide()
except Exception as e:
self.show_alert(Gtk.MessageType.ERROR,
_("Download failed"),
_("Downloading the package failed: "
"file '%s' '%s'") % (file, e))
sys.exit(1)
return file
def __on_method_call(
self,
connection,
sender,
object_path,
interface_name,
method_name,
parameters,
invocation,
):
method_fname = self.__fname(interface_name, method_name)
method_info = self.__methods[method_fname]
args = list(parameters.unpack())
context = DBusMethodCallContext(connection, sender, object_path, method_info)
job = DBusMethodCallJob(
self.application, method_info, args, invocation, context
)
cancellable = Gio.Cancellable()
old_job = self.__method_calls.pop(method_name, None)
if old_job:
old_job.cancel()
self.__method_calls[method_name] = cancellable
# TODO: Instead, call job.run_async in a thread
job.run(cancellable)
def __populate_db(self):
"""
Populate DB in a background task
"""
try:
Logger.info("Collection download started")
self.__is_running = True
self.__cancellable = Gio.Cancellable()
storage_types = []
mask = App().settings.get_value("suggestions-mask").get_int32()
# Check if storage type needs to be updated
# Check if albums newer than a week are enough
timestamp = time() - 604800
for storage_type in self.__STORAGE_TYPES:
if not mask & storage_type:
continue
newer_albums = App().albums.get_newer_for_storage_type(
storage_type, timestamp)
if len(newer_albums) < self.MIN_ITEMS_PER_STORAGE_TYPE:
storage_types.append(storage_type)
# Update needed storage types
if storage_types:
for storage_type in storage_types:
if self.__cancellable.is_cancelled():
raise Exception("cancelled")
self.__METHODS[storage_type](self, self.__cancellable)
self.clean_old_albums(storage_types)
App().artists.update_featuring()
except Exception as e:
Logger.warning("CollectionWebService::__populate_db(): %s", e)
self.__is_running = False
Logger.info("Collection download finished")
def start_verify(self, p, identify=False):
self._verify_match = None
self._verify_fp = None
self._verify_error = None
self._verify_report_match = None
self._verify_report_print = None
self._verify_completed = False
self._verify_reported = False
self._cancellable = Gio.Cancellable()
if identify:
self.assertTrue(self.dev.supports_identify())
def match_cb(dev, match, pnt, data, error):
self._verify_reported = True
self._verify_report_match = match
self._verify_report_print = pnt
self._verify_report_error = error
def verify_cb(dev, res):
try:
self._verify_match, self._verify_fp = (
dev.identify_finish(res) if identify else dev.verify_finish(res))
except gi.repository.GLib.Error as e:
self._verify_error = e
self._verify_completed = True
if identify:
self.dev.identify(p if isinstance(p, list) else [p],
cancellable=self._cancellable, match_cb=match_cb, callback=verify_cb)
else:
self.dev.verify(p, cancellable=self._cancellable, match_cb=match_cb,
callback=verify_cb)
def on_scene_called(self):
"""
Fired when the scene has been called.
"""
# Load current variant
if os.path.exists(VARIANT_FILE):
with open(VARIANT_FILE, "r") as f:
self.current_variant = f.read().strip()
# Enter in the bus
self.bus_cancellable = Gio.Cancellable()
self.bus = Gio.bus_get_sync(Gio.BusType.SYSTEM, self.bus_cancellable)
self.Channels = Gio.DBusProxy.new_sync(
self.bus, 0, None, BUS_NAME,
"/org/semplicelinux/channels/channels",
"org.semplicelinux.channels.channels", self.bus_cancellable)
self.Providers = Gio.DBusProxy.new_sync(
self.bus, 0, None, BUS_NAME,
"/org/semplicelinux/channels/providers",
"org.semplicelinux.channels.providers", self.bus_cancellable)
# We are locked
self.unlockbar.emit("locked")
self.load()
def __init__(self):
"""
Init playbin
"""
BasePlayer.__init__(self)
self.__cancellable = Gio.Cancellable()
self.__codecs = Codecs()
self._playbin = self.__playbin1 = Gst.ElementFactory.make(
"playbin", "player")
self.__playbin2 = Gst.ElementFactory.make("playbin", "player")
self._plugins = self._plugins1 = PluginsPlayer(self.__playbin1)
self._plugins2 = PluginsPlayer(self.__playbin2)
self._playbin.connect("notify::volume", self.__on_volume_changed)
for playbin in [self.__playbin1, self.__playbin2]:
flags = playbin.get_property("flags")
flags &= ~GstPlayFlags.GST_PLAY_FLAG_VIDEO
playbin.set_property("flags", flags)
playbin.set_property("buffer-size", 5 << 20)
playbin.set_property("buffer-duration", 10 * Gst.SECOND)
playbin.connect("about-to-finish",
self._on_stream_about_to_finish)
bus = playbin.get_bus()
bus.add_signal_watch()
bus.connect("message::error", self._on_bus_error)
bus.connect("message::eos", self._on_bus_eos)
bus.connect("message::element", self._on_bus_element)
bus.connect("message::stream-start", self._on_stream_start)
bus.connect("message::tag", self._on_bus_message_tag)
self._start_time = 0
