Merge lp:~fabiozaramella/wingpanel-indicator-sound/implement-bluetooth-controls into lp:~wingpanel-devs/wingpanel-indicator-sound/trunk

[Fabio Zaramella]

Implements controls for paired bluetooth devices

This branch implements controls for paired bluetooth devices.

=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2016-12-22 19:28:43 +0000
+++ src/CMakeLists.txt	2017-04-09 16:26:45 +0000
@@ -22,6 +22,10 @@
   Services/MprisClient.vala
   Services/Settings.vala
   Services/Volume-control.vala
+  Services/Manager.vala
+  Services/Adapter.vala
+  Services/Device.vala
+  Services/MediaPlayer.vala
   ${CMAKE_CURRENT_BINARY_DIR}/config.vala
 PACKAGES
   wingpanel-2.0

=== added file 'src/Services/Adapter.vala'
--- src/Services/Adapter.vala	1970-01-01 00:00:00 +0000
+++ src/Services/Adapter.vala	2017-04-09 16:26:45 +0000
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2015-2017 elementary LLC. (http://launchpad.net/wingpanel-indicator-sound)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public
+ * License along with this program; If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+[DBus (name = "org.bluez.Adapter1")]
+public interface Sound.Services.Adapter : Object {
+	public abstract void remove_device (ObjectPath device) throws IOError;
+	public abstract void set_discovery_filter (HashTable<string, Variant> properties) throws IOError;
+	public abstract void start_discovery () throws IOError;
+	public abstract void stop_discovery () throws IOError;
+
+	public abstract string[] UUIDs { public owned get; private set; }
+	public abstract bool discoverable { public get; public set; }
+	public abstract bool discovering { public get; private set; }
+	public abstract bool pairable { public get; public set; }
+	public abstract bool powered { public get; public set; }
+	public abstract string address { public owned get; private set; }
+	public abstract string alias { public owned get; public set; }
+	public abstract string modalias { public owned get; private set; }
+	public abstract string name { public owned get; private set; }
+	public abstract uint @class { public get; private set; }
+	public abstract uint discoverable_timeout { public get; private set; }
+	public abstract uint pairable_timeout { public get; private set; }
+}

=== added file 'src/Services/Device.vala'
--- src/Services/Device.vala	1970-01-01 00:00:00 +0000
+++ src/Services/Device.vala	2017-04-09 16:26:45 +0000
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2015-2017 elementary LLC. (http://launchpad.net/wingpanel-indicator-sound)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public
+ * License along with this program; If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+[DBus (name = "org.bluez.Device1")]
+public interface Sound.Services.Device : Object {
+	public abstract void cancel_pairing () throws IOError;
+	public abstract void connect () throws IOError;
+	public abstract void connect_profile (string UUID) throws IOError;
+	public abstract void disconnect () throws IOError;
+	public abstract void disconnect_profile (string UUID) throws IOError;
+	public abstract void pair () throws IOError;
+
+	public abstract string[] UUIDs { public owned get; private set; }
+	public abstract bool blocked { public owned get; public set; }
+	public abstract bool connected { public owned get; private set; }
+	public abstract bool legacy_pairing { public owned get; private set; }
+	public abstract bool paired { public owned get; private set; }
+	public abstract bool trusted { public owned get; public set; }
+	public abstract int16 RSSI { public owned get; private set; }
+	public abstract ObjectPath adapter { public owned get; private set; }
+	public abstract string address { public owned get; private set; }
+	public abstract string alias { public owned get; public set; }
+	public abstract string icon { public owned get; private set; }
+	public abstract string modalias { public owned get; private set; }
+	public abstract string name { public owned get; private set; }
+	public abstract uint16 appearance { public owned get; private set; }
+	public abstract uint32 @class { public owned get; private set; }
+}

=== added file 'src/Services/Manager.vala'
--- src/Services/Manager.vala	1970-01-01 00:00:00 +0000
+++ src/Services/Manager.vala	2017-04-09 16:26:45 +0000
@@ -0,0 +1,257 @@
+/*
+ * Copyright (c) 2015-2017 elementary LLC. (http://launchpad.net/wingpanel-indicator-sound)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public
+ * License along with this program; If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+[DBus (name = "org.freedesktop.DBus.ObjectManager")]
+public interface Sound.Services.DBusInterface : Object {
+    public signal void interfaces_added (ObjectPath object_path, HashTable<string, HashTable<string, Variant>> param);
+    public signal void interfaces_removed (ObjectPath object_path, string[] string_array);
+
+    public abstract HashTable<ObjectPath, HashTable<string, HashTable<string, Variant>>> get_managed_objects () throws IOError;
+}
+
+public class Sound.Services.ObjectManager : Object {
+    public signal void global_state_changed (bool enabled, bool connected);
+    public signal void adapter_added (Services.Adapter adapter);
+    public signal void adapter_removed (Services.Adapter adapter);
+    public signal void device_added (Services.Device adapter);
+    public signal void device_removed (Services.Device adapter);
+    public signal void media_player_added (Services.MediaPlayer media_player, string name, string icon);
+    public signal void media_player_removed (Services.MediaPlayer media_player);
+    public signal void media_player_status_changed (string status, string title, string album);
+
+    public bool has_object { get; private set; default = false; }
+    public string media_player_status { get;  private set; default = "stopped";}
+    public string current_track_title { get;  private set; default = "Not playing";}
+    public string current_track_artist { get;  private set;}
+
+    private Services.DBusInterface object_interface;
+    private Gee.HashMap<string, Services.Adapter> adapters;
+    private Gee.HashMap<string, Services.Device> devices;
+    private Gee.HashMap<string, Services.MediaPlayer> media_players;
+
+    public ObjectManager () { }
+
+    construct {
+        adapters = new Gee.HashMap<string, Services.Adapter> (null, null);
+        devices = new Gee.HashMap<string, Services.Device> (null, null);
+        media_players = new Gee.HashMap<string, Services.MediaPlayer> (null, null);
+
+        Bus.get_proxy.begin<Services.DBusInterface> (BusType.SYSTEM, "org.bluez", "/", DBusProxyFlags.NONE, null, (obj, res) => {
+            try {
+                object_interface = Bus.get_proxy.end (res);
+                object_interface.get_managed_objects ().foreach (add_path);
+                object_interface.interfaces_added.connect (add_path);
+                object_interface.interfaces_removed.connect (remove_path);
+            } catch (Error e) {
+                critical (e.message);
+            }
+        });
+    }
+
+    [CCode (instance_pos = -1)]
+    private void add_path (ObjectPath path, HashTable<string, HashTable<string, Variant>> param) {
+        if ("org.bluez.Adapter1" in param) {
+            try {
+                Services.Adapter adapter = Bus.get_proxy_sync (BusType.SYSTEM, "org.bluez", path, DBusProxyFlags.GET_INVALIDATED_PROPERTIES);
+                lock (adapters) {
+                    adapters.set (path, adapter);
+                }
+                has_object = true;
+
+                adapter_added (adapter);
+                (adapter as DBusProxy).g_properties_changed.connect ((changed, invalid) => {
+                    var powered = changed.lookup_value ("Powered", new VariantType ("b"));
+                    if (powered != null) {
+                        check_global_state ();
+                    }
+                });
+            } catch (Error e) {
+                warning ("Connecting to bluetooth adapter failed: %s", e.message);
+            }
+        } else if ("org.bluez.Device1" in param) {
+            try {
+                Services.Device device = Bus.get_proxy_sync (BusType.SYSTEM, "org.bluez", path, DBusProxyFlags.GET_INVALIDATED_PROPERTIES);
+                if (device.paired) {
+                    lock (devices) {
+                        devices.set (path, device);
+                    }
+
+                    device_added (device);
+                }
+
+                (device as DBusProxy).g_properties_changed.connect ((changed, invalid) => {
+                    var connected = changed.lookup_value ("Connected", new VariantType ("b"));
+                    if (connected != null) {
+                        check_global_state ();
+                    }
+
+                    var paired = changed.lookup_value ("Paired", new VariantType ("b"));
+                    if (paired != null) {
+                        if (device.paired) {
+                            lock (devices) {
+                                devices.set (path, device);
+                            }
+
+                            device_added (device);
+                        } else {
+                            lock (devices) {
+                                devices.unset (path);
+                            }
+
+                            device_removed (device);
+                        }
+                    }
+                });
+            } catch (Error e) {
+                warning ("Connecting to bluetooth device failed: %s", e.message);
+            }
+        } else if ("org.bluez.MediaPlayer1" in param) {
+            try {           
+                Services.MediaPlayer media_player = Bus.get_proxy_sync (BusType.SYSTEM, "org.bluez", path, DBusProxyFlags.GET_INVALIDATED_PROPERTIES);
+                lock (media_players) {
+                    media_players.set (path, media_player);
+                }
+                string device_name = path.substring (0, path.last_index_of("/"));
+                Services.Device cur_device = Bus.get_proxy_sync (BusType.SYSTEM, "org.bluez", device_name, DBusProxyFlags.GET_INVALIDATED_PROPERTIES);
+                media_player_status = media_player.track.lookup ("Title").get_string (null);
+                media_player_added (media_player, cur_device.name, cur_device.icon);
+
+                (media_player as DBusProxy).g_properties_changed.connect ((changed, invalid) => {
+                    if (changed.print (true).contains ("Track")) {
+                        Variant tmp = changed.lookup_value ("Track", VariantType.DICTIONARY);
+                        string title = tmp.lookup_value ("Title", VariantType.STRING).get_string (null);
+                        string artist = tmp.lookup_value ("Artist", VariantType.STRING).get_string (null);
+                        current_track_title = title;
+                        current_track_artist = artist;
+                        media_player_status_changed ("", title, artist);
+                    } else if (changed.lookup("Status", "s")) {
+                        string status = changed.lookup_value ("Status", VariantType.STRING).get_string (null);
+                        media_player_status = status;
+                        media_player_status_changed (status, "", "");
+                    }
+                });
+            } catch (Error e) {
+                warning ("Connecting to bluetooth media player failed: %s", e.message);
+            }
+        }
+    }
+
+    [CCode (instance_pos = -1)]
+    public void remove_path (ObjectPath path) {
+        lock (adapters) {
+            var adapter = adapters.get (path);
+            if (adapter != null) {
+                adapters.unset (path);
+                has_object = !adapters.is_empty;
+
+                adapter_removed (adapter);
+                return;
+            }
+        }
+
+        lock (devices) {
+            var device = devices.get (path);
+            if (device != null) {
+                devices.unset (path);
+                device_removed (device);
+            }
+        }
+
+        lock (media_players) {
+            var media_player = media_players.get (path);
+            if (media_player != null) {
+                media_players.unset (path);
+                media_player_removed (media_player);
+            }
+        }
+    }
+
+    public Gee.Collection<Services.Adapter> get_adapters () {
+        lock (adapters) {
+            return adapters.values;
+        }
+    }
+
+    public Gee.Collection<Services.Device> get_devices () {
+        lock (devices) {
+            return devices.values;
+        }
+    }
+
+    public Services.Adapter? get_adapter_from_path (string path) {
+        lock (adapters) {
+            return adapters.get (path);
+        }
+    }
+
+    private void check_global_state () {
+        global_state_changed (get_global_state (), get_connected ());
+    }
+
+    public bool get_connected () {
+        lock (devices) {
+            foreach (var device in devices.values) {
+                if (device.connected) {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    public bool get_global_state () {
+        lock (adapters) {
+            foreach (var adapter in adapters.values) {
+                if (adapter.powered) {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    public void set_global_state (bool state) {
+        new Thread<void*> (null, () => {
+            lock (devices) {
+                foreach (var device in devices.values) {
+                    if (device.connected) {
+                        try {
+                            device.disconnect ();
+                        } catch (Error e) {
+                            critical (e.message);
+                        }
+                    }
+                }
+            }
+
+            lock (adapters) {
+                foreach (var adapter in adapters.values) {
+                    adapter.powered = state;
+                }
+            }
+
+            return null;
+        });
+    }
+
+    public void set_last_state () {
+        check_global_state ();
+    }
+}

=== added file 'src/Services/MediaPlayer.vala'
--- src/Services/MediaPlayer.vala	1970-01-01 00:00:00 +0000
+++ src/Services/MediaPlayer.vala	2017-04-09 16:26:45 +0000
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2015-2017 elementary LLC. (http://launchpad.net/wingpanel-indicator-sound)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public
+ * License along with this program; If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Fiorotto Giuliano <[e-mail]>
+ *              Fabio Zaramella <[e-mail]>
+ */
+
+[DBus (name = "org.bluez.MediaPlayer1")]
+public interface Sound.Services.MediaPlayer : Object {
+	public abstract void play () throws IOError;
+	public abstract void pause () throws IOError;
+	public abstract void stop () throws IOError;
+	public abstract void next () throws IOError;
+	public abstract void previous () throws IOError;
+	public abstract void fast_forward () throws IOError;
+	public abstract void rewind () throws IOError;
+	public abstract string name { public owned get; }
+	public abstract string status { public owned get; }
+	public abstract HashTable<string,Variant> track { public owned get; }
+}

=== modified file 'src/Widgets/MprisGui.vala'
--- src/Widgets/MprisGui.vala	2017-02-03 20:19:16 +0000
+++ src/Widgets/MprisGui.vala	2017-04-09 16:26:45 +0000
@@ -71,6 +71,7 @@
     }
 
     private Services.MprisClient? client_ = null;
+    private Services.MediaPlayer? mp_client = null;
 
     public Services.MprisClient? client {
         get {
@@ -120,6 +121,22 @@
     }
 
     /**
+     * Create a new ClientWidget for bluetooth controls
+     *
+     * @param client The underlying MediaPlayer instance to use
+     */
+    public ClientWidget.bluetooth (Services.MediaPlayer media_player_client, string name, string icon){
+        mp_client = media_player_client;
+
+        app_icon = new ThemedIcon (icon);
+        background.set_from_gicon (app_icon, Gtk.IconSize.DIALOG);
+        title_label.set_markup ("<b>%s</b>".printf (Markup.escape_text (name)));
+        artist_label.set_text (NOT_PLAYING);
+
+        update_controls ();
+    }
+
+    /**
      * Create a new ClientWidget for the default player
      *
      * @param info The AppInfo of the default music player
@@ -194,25 +211,33 @@
         prev_btn = btn;
         btn.clicked.connect (()=> {
             Idle.add (()=> {
-                if (client.player.can_go_previous) {
-                  if(!Thread.supported ()) {
-                      warning ("Threading is not supported. DBus timeout could be blocking UI");
-                      try {
-                          client.player.previous();
-                      } catch  (Error e) {
-                          warning ("Going to previous track probably failed (faulty MPRIS interface): %s", e.message);
-                      }
-                  } else {
-                      new Thread <void*> ("wingpanel_indicator_sound_dbus_backward_thread", () => {
-                          try {
-                              client.player.previous();
-                          } catch (Error e) {
-                              warning ("Going to previous track probably failed (faulty MPRIS interface): %s", e.message);
-                          }
-                          return null;
-                        });
-                  }
+                if (!Thread.supported ()) {
+                    warning ("Threading is not supported. DBus timeout could be blocking UI");
+                    try {
+                        if (mp_client == null && client.player.can_go_previous) {
+                            client.player.previous ();
+                        } else if (mp_client != null) {
+                            mp_client.previous ();
+                        }
+                    } catch  (Error e) {
+                        warning ("Going to previous track probably failed (faulty MPRIS interface): %s", e.message);
+                    }
+                } else {
+                    new Thread <void*> ("wingpanel_indicator_sound_dbus_backward_thread", () => {
+                        try {
+                            if (mp_client == null) {
+                                client.player.previous ();
+                            } else if(mp_client != null) {
+                                mp_client.previous ();
+                            }
+                        } catch (Error e) {
+                            warning ("Going to previous track probably failed (faulty MPRIS interface): %s", e.message);
+                        }
+
+                        return null;
+                    });
                 }
+
                 return false;
             });
         });
@@ -224,23 +249,43 @@
         play_btn = btn;
         btn.clicked.connect (()=> {
             Idle.add (()=> {
-                if(!Thread.supported ()) {
+                if (!Thread.supported ()) {
                     warning ("Threading is not supported. DBus timeout could be blocking UI");
                     try {
-                        client.player.play_pause();
-                    } catch  (Error e) {
+                        if (mp_client == null) {
+                            client.player.play_pause ();
+                        } else if (mp_client != null) {
+                            if (mp_client.status == "playing") {
+                                mp_client.pause ();
+                            } else {
+                                mp_client.play ();
+                            }
+                            update_play_status ();
+                        }
+                    } catch (Error e) {
                         warning ("Playing/Pausing probably failed (faulty MPRIS interface): %s", e.message);
                     }
                 } else {
                     new Thread <void*> ("wingpanel_indicator_sound_dbus_backward_thread", () => {
                         try {
-                            client.player.play_pause();
+                            if (mp_client == null) {
+                                client.player.play_pause ();
+                            } else if (mp_client != null) {
+                                if (mp_client.status == "playing") {
+                                    mp_client.pause (); 
+                                } else {
+                                    mp_client.play ();
+                                }
+                                update_play_status ();                              
+                            }
                         } catch (Error e) {
-                            warning ("Playing/Pausing probably failed (faulty MPRIS interface): %s", e.message);
+                        warning ("Playing/Pausing probably failed (faulty MPRIS interface): %s", e.message);
                         }
+
                         return null;
-                      });
+                    });
                 }
+
                 return false;
             });
         });
@@ -251,25 +296,33 @@
         next_btn = btn;
         btn.clicked.connect (()=> {
             Idle.add (()=> {
-                if (client.player.can_go_next) {
-                    if(!Thread.supported ()) {
-                        warning ("Threading is not supported. DBus timeout could be blocking UI");
+                if(!Thread.supported ()) {
+                    warning ("Threading is not supported. DBus timeout could be blocking UI");
+                    try {
+                        if (mp_client == null && client.player.can_go_next) {
+                            client.player.next ();
+                        } else if (mp_client != null) {
+                            mp_client.next ();
+                        }
+                    } catch (Error e) {
+                        warning ("Going to next track probably failed (faulty MPRIS interface): %s", e.message);
+                    }
+                } else {
+                    new Thread <void*> ("wingpanel_indicator_sound_dbus_forward_thread", () => {
                         try {
-                            client.player.next();
-                        } catch  (Error e) {
+                            if (mp_client == null) {
+                                client.player.next ();
+                            } else if (mp_client != null) {
+                                mp_client.next ();
+                            }
+                        } catch (Error e) {
                             warning ("Going to next track probably failed (faulty MPRIS interface): %s", e.message);
                         }
-                    } else {
-                        new Thread <void*> ("wingpanel_indicator_sound_dbus_forward_thread", () => {
-                            try {
-                                client.player.next();
-                            } catch (Error e) {
-                                warning ("Going to next track probably failed (faulty MPRIS interface): %s", e.message);
-                            }
-                            return null;
-                          });
-                    }
+
+                        return null;
+                    });
                 }
+
                 return false;
             });
         });
@@ -295,7 +348,7 @@
 
     private void connect_to_client () {
         client.prop.properties_changed.connect ((i,p,inv)=> {
-            if  (i == "org.mpris.MediaPlayer2.Player") {
+            if (i == "org.mpris.MediaPlayer2.Player") {
                 /* Handle mediaplayer2 iface */
                 p.foreach ((k,v)=> {
                     if (k == "Metadata") {
@@ -323,17 +376,17 @@
         try {
             close ();
             if (client != null && client.player.can_raise) {
-                if(!Thread.supported ()) {
+                if (!Thread.supported ()) {
                     warning ("Threading is not supported. DBus timeout could be blocking UI");
                     try {
-                        client.player.raise();
+                        client.player.raise ();
                     } catch  (Error e) {
                         warning ("Raising the player probably failed (faulty MPRIS interface): %s", e.message);
                     }
                 } else {
                     new Thread <void*> ("wingpanel_indicator_sound_dbus_backward_thread", () => {
                         try {
-                            client.player.raise();
+                            client.player.raise ();
                         } catch (Error e) {
                             warning ("Raising the player probably failed (faulty MPRIS interface): %s", e.message);
                         }
@@ -343,7 +396,7 @@
             } else if (app_info != null) {
                 app_info.launch (null, null);
             }
-        } catch  (Error e) {
+        } catch (Error e) {
             warning ("Could not launch player");
         }
 
@@ -376,11 +429,11 @@
     private void update_play_status () {
         switch  (client.player.playback_status) {
             case "Playing":
-                 (play_btn.get_image () as Gtk.Image).set_from_icon_name ("media-playback-pause-symbolic", Gtk.IconSize.LARGE_TOOLBAR);
+                (play_btn.get_image () as Gtk.Image).set_from_icon_name ("media-playback-pause-symbolic", Gtk.IconSize.LARGE_TOOLBAR);
                 break;
             default:
                 /* Stopped, Paused */
-                 (play_btn.get_image () as Gtk.Image).set_from_icon_name ("media-playback-start-symbolic", Gtk.IconSize.LARGE_TOOLBAR);
+                (play_btn.get_image () as Gtk.Image).set_from_icon_name ("media-playback-start-symbolic", Gtk.IconSize.LARGE_TOOLBAR);
                 break;
         }
     }
@@ -389,8 +442,13 @@
      * Update prev/next sensitivity based on player requirements
      */
     private void update_controls () {
-        prev_btn.set_sensitive (client.player.can_go_previous);
-        next_btn.set_sensitive (client.player.can_go_next);
+        if (mp_client == null) {
+            prev_btn.set_sensitive (client.player.can_go_previous);
+            next_btn.set_sensitive (client.player.can_go_next);
+        } else {
+            prev_btn.set_sensitive (true);
+            next_btn.set_sensitive (true);
+        }
     }
 
     /**
@@ -498,4 +556,23 @@
 
         return Gdk.pixbuf_get_from_surface (surface, 0, 0, mask_size, mask_size);
     }
+
+    public void update_play (string playing, string title, string artist) {
+        if (playing != "") {
+            switch (playing) {
+                case "playing":
+                    (play_btn.get_image () as Gtk.Image).set_from_icon_name ("media-playback-pause-symbolic", Gtk.IconSize.LARGE_TOOLBAR);
+                    break;
+                default:
+                    /* Stopped, Paused */
+                    (play_btn.get_image () as Gtk.Image).set_from_icon_name ("media-playback-start-symbolic", Gtk.IconSize.LARGE_TOOLBAR);
+                    break;
+            }
+        }
+
+        if (title != "" && artist != "") {
+            title_label.set_markup ("<b>%s</b>".printf (Markup.escape_text (title)));
+            artist_label.set_text (artist);
+        }
+    }
 }

=== modified file 'src/Widgets/MprisWidget.vala'
--- src/Widgets/MprisWidget.vala	2017-02-03 20:19:16 +0000
+++ src/Widgets/MprisWidget.vala	2017-04-09 16:26:45 +0000
@@ -21,9 +21,12 @@
 
     AppInfo? default_music;
     ClientWidget default_widget;
+    ClientWidget bluetooth_widget;
     HashTable<string,ClientWidget> ifaces;
     public signal void close ();
 
+    public Sound.Services.ObjectManager object_manager;
+
     public MprisWidget() {
         Object (orientation: Gtk.Orientation.VERTICAL, spacing: 1);
 
@@ -46,6 +49,39 @@
             pack_start(default_widget, false, false, 0);
         }
 
+        object_manager = new Services.ObjectManager ();
+        object_manager.bind_property ("has-object", this, "visible", GLib.BindingFlags.SYNC_CREATE);
+
+        if (object_manager.has_object) {
+            object_manager.set_last_state ();
+        }
+
+        object_manager.media_player_added.connect ((media_player, name, icon) => {
+            try { 
+                bluetooth_widget = new ClientWidget.bluetooth (media_player, name, icon);
+                bluetooth_widget.close.connect (() => {
+                    close ();
+                });
+
+                bluetooth_widget.show_all ();
+                pack_start (bluetooth_widget, false, false, 0);
+            } catch (Error e) {
+                warning ("Connecting to bluetooth device failed: %s", e.message);
+            }
+        });
+
+        object_manager.media_player_removed.connect ((media_player) => {
+            debug ("Media player %s removed", media_player.name);
+            bluetooth_widget.destroy ();
+        });
+
+        object_manager.media_player_status_changed.connect ((status, title, artist) => {
+            bluetooth_widget.update_play (status, title, artist);
+            if (status == "playing" && default_widget.client.player.playback_status == "Playing") {
+                default_widget.client.player.play_pause ();
+            }
+        });
+
         show_all();
     }