Merge lp:~phablet-team/messaging-framework/enable_message_broadcast into lp:messaging-framework

[Gustavo Pichorim Boiko]

Add a broadcast recipient type and make it possible to use broadcast text
channels.

Add a broadcast recipient type and make it possible to use broadcast text
channels.

[system-apps-ci-bot (system-apps-ci-bot)]

FAILED: Continuous integration, rev:62
https://jenkins.canonical.com/system-apps/job/lp-messaging-framework-ci/75/
Executed test runs:
    FAILURE: https://jenkins.canonical.com/system-apps/job/build/1541/console
    SUCCESS: https://jenkins.canonical.com/system-apps/job/build-0-fetch/1541
    SUCCESS: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=amd64,release=vivid+overlay/1389
        deb: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=amd64,release=vivid+overlay/1389/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=amd64,release=xenial+overlay/1389
        deb: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=amd64,release=xenial+overlay/1389/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=amd64,release=yakkety/1389
        deb: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=amd64,release=yakkety/1389/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=armhf,release=vivid+overlay/1389
        deb: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=armhf,release=vivid+overlay/1389/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=armhf,release=xenial+overlay/1389
        deb: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=armhf,release=xenial+overlay/1389/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=armhf,release=yakkety/1389
        deb: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=armhf,release=yakkety/1389/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=i386,release=vivid+overlay/1389
        deb: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=i386,release=vivid+overlay/1389/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=i386,release=xenial+overlay/1389
        deb: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=i386,release=xenial+overlay/1389/artifact/output/*zip*/output.zip
    FAILURE: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=i386,release=yakkety/1389/console

Click here to trigger a rebuild:
https://jenkins.canonical.com/system-apps/job/lp-messaging-framework-ci/75/rebuild

review: Needs Fixing (continuous-integration)

[lp:~phablet-team/messaging-framework/enable_message_broadcast]

63. By Roberto Mier Escandon on 2016-09-17

merged prereq branch

64. By Gustavo Pichorim Boiko on 2016-09-27

Do not crash if the Roles interface is not available

65. By Gustavo Pichorim Boiko on 2016-09-28

Use an ID for the broadcast recipient.

66. By Roberto Mier Escandon on 2016-09-28

merged prereq lp:~phablet-team/messaging-framework/fix-roles-interface-event

67. By Roberto Mier Escandon on 2016-09-28

creating broadcast using group_starter, for it to have an initial id

Unmerged revisions

=== modified file 'debian/changelog'
--- debian/changelog	2016-08-25 20:07:12 +0000
+++ debian/changelog	2016-09-17 21:47:53 +0000
@@ -1,3 +1,21 @@
+messaging-framework (0.1-1ubuntu28) vivid; urgency=medium
+
+  * Subject interface
+
+ -- Roberto Mier Escandon <[e-mail]>  Wed, 14 Sep 2016 13:04:50 +0200
+
+messaging-framework (0.1-1ubuntu27) vivid; urgency=medium
+
+  * snapshot
+
+ -- Roberto Mier Escandon <[e-mail]>  Tue, 13 Sep 2016 18:11:06 +0200
+
+messaging-framework (0.1-1ubuntu26) vivid; urgency=medium
+
+  * Group has additional properties if plugins want to add there their specific values
+
+ -- Roberto Mier Escandon <[e-mail]>  Mon, 12 Sep 2016 17:01:04 +0200
+
 messaging-framework (0.1-1ubuntu25) vivid; urgency=medium
 
   * Fixed self handle included in members

=== added file 'include/messaging/broadcast.h'
--- include/messaging/broadcast.h	1970-01-01 00:00:00 +0000
+++ include/messaging/broadcast.h	2016-09-17 21:47:53 +0000
@@ -0,0 +1,45 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef BROADCAST_H
+#define BROADCAST_H
+
+#include <messaging/recipient.h>
+#include <messaging/member.h>
+#include <messaging/members.h>
+
+namespace messaging
+{
+
+class MESSAGING_FW_PUBLIC Broadcast : public Recipient
+{
+public:
+    Broadcast(const Members &members = Members{});
+
+    RecipientType type() const override;
+    Members members() const;
+
+    typedef std::shared_ptr<Broadcast> shared_ptr;
+private:
+    /// @cond
+    struct Private;
+    std::shared_ptr<Private> impl;
+    /// @endcond
+};
+
+}
+
+#endif // BROADCAST_H

=== modified file 'include/messaging/group.h'
--- include/messaging/group.h	2016-08-17 13:25:23 +0000
+++ include/messaging/group.h	2016-09-17 21:47:53 +0000
@@ -27,15 +27,28 @@
 class MESSAGING_FW_PUBLIC Group : public Recipient
 {
 public:
+    static const std::string ROOM_NAME;
+    static const std::string DESCRIPTION;
+    static const std::string SERVER;
+    static const std::string CREATION_TIMESTAMP;
+    static const std::string SUBJECT;
+
     Group(std::string id, 
     	const Members &initial_invitees = Members{}, 
     	std::string initial_title = std::string{}, 
-    	const std::shared_ptr<Member> &creator = std::make_shared<Member>(std::string{}));
-    
+        const std::shared_ptr<Member> &creator = std::make_shared<Member>(std::string{}),
+        const VariantMap &additional_properties = VariantMap{});
+
     RecipientType type() const override;
+
     Members initial_invitees() const;
     std::string initial_title() const;
     std::shared_ptr<Member> creator() const;
+    VariantMap &additional_properties();
+
+    std::shared_ptr<Variant> additional_property(const std::string &key) const;
+    void set_additional_property(const std::string &key, const std::shared_ptr<messaging::Variant> &value);
+    bool exists_additional_property(const std::string &key) const;
 
     typedef std::shared_ptr<Group> shared_ptr;
 private:

=== modified file 'include/messaging/group_manager.h'
--- include/messaging/group_manager.h	2016-08-25 11:04:57 +0000
+++ include/messaging/group_manager.h	2016-09-17 21:47:53 +0000
@@ -33,11 +33,12 @@
 // Maintain sequence of 2 multiples if adding new values to preserve flags management
 enum class GroupPermissions : uint
 {
-    NoPermissions   = 0,      //0
-    CanChangeTitle  = 1 << 0, //1
-    CanKick         = 1 << 1, //2
-    CanSetAdmin     = 1 << 2, //4
-    CanDissolve     = 1 << 3  //8
+    NoPermissions       = 0,      //0
+    CanChangeTitle      = 1 << 0, //1
+    CanKick             = 1 << 1, //2
+    CanSetAdmin         = 1 << 2, //4
+    CanDissolve         = 1 << 3, //8
+    CanChangeSubject    = 1 << 4  //16
 };
 
 enum class CancelGroupReason
@@ -62,8 +63,9 @@
 
         virtual void on_group_created() = 0;
         virtual void on_group_cancelled(CancelGroupReason reason, const std::string &message) = 0;
-        virtual void on_group_title_changed(const std::string& new_title,
-                                            const Member& actor,
+        virtual void on_group_title_changed(const std::string& new_title) = 0;
+        virtual void on_group_subject_changed(const std::string& new_subject,
+                                            const std::shared_ptr<Member>& actor,
                                             const std::chrono::system_clock::time_point& when) = 0;
         virtual void on_members_updated(const Members& members) = 0;
         virtual void on_group_permissions_changed(const Flags<GroupPermissions> &permissions) = 0;
@@ -88,12 +90,18 @@
     /// @brief change_group_title modifies the title of the group
     virtual void change_group_title(const std::string& title) = 0;
 
+    /// @brief change_group_subject modifies the subject of the group
+    virtual void change_group_subject(const std::string& subject) = 0;
+
     /// @brief group_id returns the id of the group being managed
     virtual std::string group_id() = 0;
 
     /// @brief group_title returns the title of the group being managed
     virtual std::string group_title() = 0;
 
+    /// @brief group_subject returns the subject of the group being managed
+    virtual std::string group_subject() = 0;
+
     /// @brief creator returns the creator of the group being managed
     virtual std::shared_ptr<Member> group_creator() = 0;
 
@@ -117,9 +125,10 @@
 
     void announce_group_created();
     void announce_group_cancelled(CancelGroupReason reason, const std::string& message);
-    void announce_group_title_changed(const std::string& new_title,
-                                      const Member& actor = Member{std::string{}},
-                                      const std::chrono::system_clock::time_point& when = std::chrono::system_clock::now());
+    void announce_group_title_changed(const std::string& new_title);
+    void announce_group_subject_changed(const std::string& new_subject,
+                                        const std::shared_ptr<Member>& actor = std::make_shared<Member>(std::string{}),
+                                        const std::chrono::system_clock::time_point& when = std::chrono::system_clock::now());
     void announce_members_updated(const Members& members);
     void announce_group_permissions_changed(const Flags<GroupPermissions> &permissions);
 

=== modified file 'include/messaging/has_interfaces.h'
--- include/messaging/has_interfaces.h	2016-03-30 19:19:19 +0000
+++ include/messaging/has_interfaces.h	2016-09-17 21:47:53 +0000
@@ -22,7 +22,7 @@
 namespace messaging
 {
 
-class MESSAGING_FW_PUBLIC HasInterfaces
+class MESSAGING_FW_PUBLIC HasInterfaces : public std::enable_shared_from_this<HasInterfaces>
 {
 public:
     virtual ~HasInterfaces() = default;
@@ -51,6 +51,10 @@
 protected:
     HasInterfaces();
 
+    /// @brief on_interface_plugged overwrite this virtual method in subclasses if wanted to perform any action when
+    /// certain interface is plugged
+    virtual void on_interface_plugged(const std::shared_ptr<Interface>& interface);
+
 private:
     /// @cond
     struct Private;

=== modified file 'include/messaging/interface.h'
--- include/messaging/interface.h	2016-03-30 19:19:19 +0000
+++ include/messaging/interface.h	2016-09-17 21:47:53 +0000
@@ -26,6 +26,7 @@
 namespace messaging
 {
 
+class HasInterfaces;
 class Interface;
 
 typedef std::set<std::shared_ptr<Interface>, std::owner_less<std::shared_ptr<Interface>>> InterfacesSet;
@@ -34,6 +35,10 @@
 {
 public:
     virtual ~Interface() = default;
+
+    /// @brief on_plugged executed when this interfaces is plugged to a host object. Overwrite this method
+    /// in subclasses if wanted certain behaviour when plug happens.
+    virtual void on_plugged(const std::weak_ptr<HasInterfaces> &where) = 0;
 };
 
 }

=== added file 'include/messaging/qt/tp/interfaces/base_channel_subject.h'
--- include/messaging/qt/tp/interfaces/base_channel_subject.h	1970-01-01 00:00:00 +0000
+++ include/messaging/qt/tp/interfaces/base_channel_subject.h	2016-09-17 21:47:53 +0000
@@ -0,0 +1,88 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef MESSAGING_QT_TP_INTERFACES_BASE_CHANNEL_SUBJECT_H
+#define MESSAGING_QT_TP_INTERFACES_BASE_CHANNEL_SUBJECT_H
+
+#include <TelepathyQt/BaseChannel>
+
+#include <messaging/visibility.h>
+
+#include <messaging/qt/tp/interfaces/types.h>
+
+namespace messaging
+{
+namespace qt
+{
+namespace tp
+{
+namespace interfaces
+{
+
+class MESSAGING_FW_LOCAL BaseChannelSubjectInterface : public Tp::AbstractChannelInterface
+{
+    Q_OBJECT
+    Q_DISABLE_COPY(BaseChannelSubjectInterface)
+
+public:
+    static BaseChannelSubjectInterfacePtr create() {
+        return BaseChannelSubjectInterfacePtr(new BaseChannelSubjectInterface());
+    }
+    template<typename BaseChannelSubjectInterfaceSubclass>
+    static Tp::SharedPtr<BaseChannelSubjectInterfaceSubclass> create() {
+        return Tp::SharedPtr<BaseChannelSubjectInterfaceSubclass>(
+                   new BaseChannelSubjectInterfaceSubclass());
+    }
+    virtual ~BaseChannelSubjectInterface();
+
+    QVariantMap immutableProperties() const;
+
+    QString subject() const;
+    void setSubject(const QString& subject);
+
+    QString actor() const;
+    void setActor(const QString &actor);
+
+    uint actorHandle() const;
+    void setActorHandle(uint handle);
+
+    qlonglong timestamp() const;
+    void setTimestamp(qlonglong timestamp);
+
+    bool canSet() const;
+    void setCanSet(bool canSet);
+
+    typedef Tp::Callback2<void, const QString&, Tp::DBusError*> SetSubjectCallback;
+    void setSetSubjectCallback(const SetSubjectCallback &cb);
+    void setSubject(const QString &subject, Tp::DBusError *error);
+
+private:
+    BaseChannelSubjectInterface();
+    void createAdaptor();
+
+    class Adaptee;
+    friend class Adaptee;
+    struct Private;
+    friend struct Private;
+    Private *mPriv;
+};
+
+
+}
+}
+}
+}
+#endif // MESSAGING_QT_TP_INTERFACES_BASE_CHANNEL_SUBJECT_H

=== added file 'include/messaging/qt/tp/interfaces/base_channel_subject_internal.h'
--- include/messaging/qt/tp/interfaces/base_channel_subject_internal.h	1970-01-01 00:00:00 +0000
+++ include/messaging/qt/tp/interfaces/base_channel_subject_internal.h	2016-09-17 21:47:53 +0000
@@ -0,0 +1,59 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef MESSAGING_QT_TP_INTERFACES_BASE_CHANNEL_SUBJECT_INTERNAL_H_
+#define MESSAGING_QT_TP_INTERFACES_BASE_CHANNEL_SUBJECT_INTERNAL_H_
+
+#include <TelepathyQt/_gen/svc-channel.h>
+#include <messaging/qt/tp/interfaces/base_channel_subject.h>
+#include <messaging/visibility.h>
+
+namespace messaging
+{
+namespace qt
+{
+namespace tp
+{
+namespace interfaces
+{
+
+class MESSAGING_FW_LOCAL BaseChannelSubjectInterface::Adaptee : public QObject
+{
+    Q_OBJECT
+public:
+    Adaptee(BaseChannelSubjectInterface *interface);
+    ~Adaptee();
+
+    QString subject() const;
+    QString actor() const;
+    uint actorHandle() const;
+    qlonglong timestamp() const;
+    bool canSet() const;
+
+public Q_SLOTS:
+    void setSubject(const QString &subject, const Tp::Service::ChannelInterfaceSubjectAdaptor::SetSubjectContextPtr &context);
+
+public:
+    BaseChannelSubjectInterface *mInterface;
+};
+
+}
+}
+}
+}
+
+#endif // MESSAGING_QT_TP_INTERFACES_BASE_CHANNEL_SUBJECT_INTERNAL_H_
+

=== modified file 'include/messaging/qt/tp/interfaces/channel_interface_roles_adaptor.h'
--- include/messaging/qt/tp/interfaces/channel_interface_roles_adaptor.h	2016-08-11 21:39:57 +0000
+++ include/messaging/qt/tp/interfaces/channel_interface_roles_adaptor.h	2016-09-17 21:47:53 +0000
@@ -13,6 +13,7 @@
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
+
 #ifndef MESSAGING_QT_TP_INTERFACES_CHANNEL_INTERFACE_ROLES_ADAPTOR_H
 #define MESSAGING_QT_TP_INTERFACES_CHANNEL_INTERFACE_ROLES_ADAPTOR_H
 

=== modified file 'include/messaging/qt/tp/interfaces/types.h'
--- include/messaging/qt/tp/interfaces/types.h	2016-08-16 16:23:42 +0000
+++ include/messaging/qt/tp/interfaces/types.h	2016-09-17 21:47:53 +0000
@@ -33,10 +33,11 @@
 
 class BaseChannelDestroyableInterface;
 class BaseChannelRolesInterface;
+class BaseChannelSubjectInterface;
 
 typedef Tp::SharedPtr<BaseChannelDestroyableInterface> BaseChannelDestroyableInterfacePtr;
 typedef Tp::SharedPtr<BaseChannelRolesInterface> BaseChannelRolesInterfacePtr;
-
+typedef Tp::SharedPtr<BaseChannelSubjectInterface> BaseChannelSubjectInterfacePtr;
 
 /**
  * \struct HandleRolesMap

=== modified file 'include/messaging/qt/tp/text_channel.h'
--- include/messaging/qt/tp/text_channel.h	2016-08-30 18:46:08 +0000
+++ include/messaging/qt/tp/text_channel.h	2016-09-17 21:47:53 +0000
@@ -23,6 +23,7 @@
 
 #include <messaging/qt/tp/interfaces/base_channel_destroyable.h>
 #include <messaging/qt/tp/interfaces/base_channel_roles.h>
+#include <messaging/qt/tp/interfaces/base_channel_subject.h>
 #include <messaging/qt/tp/interfaces/types.h>
 #include <messaging/qt/tp/interfaces/constants.h>
 
@@ -81,8 +82,11 @@
     void on_group_cancelled(CancelGroupReason reason, const std::string &message) override;
 
     /// @brief on_group_title_changed when group title has changed in the server
-    void on_group_title_changed(const std::string& new_title,
-                                const Member& actor,
+    void on_group_title_changed(const std::string& new_title) override;
+
+    /// @brief on_group_subject_changed when group title has changed in the server
+    void on_group_subject_changed(const std::string& new_subject,
+                                const std::shared_ptr<Member>& actor,
                                 const std::chrono::system_clock::time_point& when) override;
 
     /// @brief on_members_updated when group members have changed (added/removed) in server
@@ -148,9 +152,12 @@
         void on_group_cancelled(CancelGroupReason reason, const std::string &message) override;
 
         /// @brief on_group_title_changed when group title has changed in the server
-        void on_group_title_changed(const std::string& new_title,
-                                    const Member& actor,
-                                    const std::chrono::system_clock::time_point& when) override;
+        void on_group_title_changed(const std::string& new_title) override;
+
+        /// @brief on_group_subject_changed when group title has changed in the server
+        void on_group_subject_changed(const std::string& new_subject,
+                                      const std::shared_ptr<Member>& actor,
+                                      const std::chrono::system_clock::time_point& when) override;
 
         /// @brief on_members_updated when group members have changed (added/removed) in server
         void on_members_updated(const Members& members) override;
@@ -192,6 +199,8 @@
     void update_group_configuration(const QVariantMap &properties, Tp::DBusError *error);
     // Handler action to update roles for current channel group members
     void update_roles(const interfaces::HandleRolesMap &contact_roles, Tp::DBusError *error);
+    // Handle action to update current channel subject
+    void set_subject(const QString &subject, Tp::DBusError *error);
 
     // channel destruction request. only supported in group chats
     void destroy(Tp::DBusError* error);
@@ -211,6 +220,7 @@
     Tp::BaseChannelChatStateInterfacePtr chat_state_interface;
     interfaces::BaseChannelDestroyableInterfacePtr destroyable_interface;
     interfaces::BaseChannelRolesInterfacePtr roles_interface;
+    interfaces::BaseChannelSubjectInterfacePtr subject_interface;
 
     // NOTE(rmescandon): this is a temporal member in the class not needed from Telepathy Qt >= 0.9.7.0 which
     // includes Tp::BaseChannel::connection() method to obtain it whenever is needed.

=== modified file 'include/messaging/recipient.h'
--- include/messaging/recipient.h	2016-03-30 19:19:19 +0000
+++ include/messaging/recipient.h	2016-09-17 21:47:53 +0000
@@ -26,7 +26,8 @@
 enum RecipientType
 {
     user,       ///< the peer is a user
-    group       ///< the peer is a group
+    group,      ///< the peer is a group
+    broadcast   ///< the peer is a broadcast group
 };
 
 class MESSAGING_FW_PUBLIC Recipient

=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2016-08-26 14:11:06 +0000
+++ src/CMakeLists.txt	2016-09-17 21:47:53 +0000
@@ -9,6 +9,8 @@
                                ${CMAKE_SOURCE_DIR}/include/messaging/qt/tp/interfaces/base_channel_destroyable_internal.h
                                ${CMAKE_SOURCE_DIR}/include/messaging/qt/tp/interfaces/base_channel_roles.h
                                ${CMAKE_SOURCE_DIR}/include/messaging/qt/tp/interfaces/base_channel_roles_internal.h
+                               ${CMAKE_SOURCE_DIR}/include/messaging/qt/tp/interfaces/base_channel_subject.h
+                               ${CMAKE_SOURCE_DIR}/include/messaging/qt/tp/interfaces/base_channel_subject_internal.h
                                ${CMAKE_SOURCE_DIR}/include/messaging/qt/tp/interfaces/channel_interface_roles_adaptor.h)
 
 set(
@@ -16,6 +18,7 @@
 
     messaging/associative_connector_factory.cpp
     messaging/boost/variant.cpp
+    messaging/broadcast.cpp
     messaging/chat.cpp
     messaging/group.cpp
     messaging/group_manager.cpp
@@ -48,6 +51,7 @@
 
     messaging/qt/tp/interfaces/base_channel_destroyable.cpp
     messaging/qt/tp/interfaces/base_channel_roles.cpp
+    messaging/qt/tp/interfaces/base_channel_subject.cpp
     messaging/qt/tp/interfaces/channel_interface_roles_adaptor.cpp
 
     messaging/runner.cpp

=== added file 'src/messaging/broadcast.cpp'
--- src/messaging/broadcast.cpp	1970-01-01 00:00:00 +0000
+++ src/messaging/broadcast.cpp	2016-09-17 21:47:53 +0000
@@ -0,0 +1,37 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <messaging/broadcast.h>
+
+struct messaging::Broadcast::Private
+{
+    messaging::Members members;
+};
+
+messaging::Broadcast::Broadcast(const messaging::Members &members)
+        : Recipient{std::string{}}, impl{new Private{members}}
+{
+}
+
+messaging::RecipientType messaging::Broadcast::type() const
+{
+    return messaging::RecipientType::broadcast;
+}
+
+messaging::Members messaging::Broadcast::members() const
+{
+    return impl->members;
+}

=== modified file 'src/messaging/group.cpp'
--- src/messaging/group.cpp	2016-08-17 13:25:23 +0000
+++ src/messaging/group.cpp	2016-09-17 21:47:53 +0000
@@ -16,15 +16,24 @@
 
 #include <messaging/group.h>
 
+#include <messaging/qt/variant.h>
+
+const std::string messaging::Group::ROOM_NAME = "roomName";
+const std::string messaging::Group::DESCRIPTION = "description";
+const std::string messaging::Group::SERVER = "server";
+const std::string messaging::Group::CREATION_TIMESTAMP = "creationTimestamp";
+const std::string messaging::Group::SUBJECT = "subject";
+
 struct messaging::Group::Private
 {
     messaging::Members initial_invitees;
     std::string initial_title;
     std::shared_ptr<messaging::Member> creator;
+    messaging::VariantMap additional_properties;
 };
 
-messaging::Group::Group(std::string id, const messaging::Members &initial_invitees, std::string initial_title, const std::shared_ptr<Member> &creator)
-        : Recipient{id}, impl{new Private{initial_invitees, initial_title, creator}}
+messaging::Group::Group(std::string id, const messaging::Members &initial_invitees, std::string initial_title, const std::shared_ptr<Member> &creator, const VariantMap &additional_properties)
+        : Recipient{id}, impl{new Private{initial_invitees, initial_title, creator, additional_properties}}
 {
 }
 
@@ -45,5 +54,30 @@
 
 std::shared_ptr<messaging::Member> messaging::Group::creator() const
 {
-	return impl->creator;
+    return impl->creator;
+}
+
+messaging::VariantMap &messaging::Group::additional_properties()
+{
+    return impl->additional_properties;
+}
+
+std::shared_ptr<messaging::Variant> messaging::Group::additional_property(const std::string &key) const
+{
+    auto it = impl->additional_properties.find(key);
+    if (it != impl->additional_properties.end()) {
+        return it->second;
+    }
+    return std::make_shared<messaging::qt::Variant>(QVariant{});
+}
+
+void messaging::Group::set_additional_property(const std::string &key, const std::shared_ptr<messaging::Variant> &value)
+{
+    impl->additional_properties[key] = value;
+}
+
+bool messaging::Group::exists_additional_property(const std::string &key) const
+{
+    auto it = impl->additional_properties.find(key);
+    return it != impl->additional_properties.end();
 }

=== modified file 'src/messaging/group_manager.cpp'
--- src/messaging/group_manager.cpp	2016-08-25 11:04:57 +0000
+++ src/messaging/group_manager.cpp	2016-09-17 21:47:53 +0000
@@ -64,12 +64,18 @@
     impl->observer->on_group_cancelled(reason, message);
 }
 
-void messaging::GroupManager::announce_group_title_changed(const std::string &new_title,
-                                                           const Member &actor,
-                                                           const std::chrono::system_clock::time_point &when)
-{
-    validate_observer();
-    impl->observer->on_group_title_changed(new_title, actor, when);
+void messaging::GroupManager::announce_group_title_changed(const std::string &new_title)
+{
+    validate_observer();
+    impl->observer->on_group_title_changed(new_title);
+}
+
+void messaging::GroupManager::announce_group_subject_changed(const std::string &new_subject,
+                                                             const std::shared_ptr<Member> &actor,
+                                                             const std::chrono::system_clock::time_point &when)
+{
+    validate_observer();
+    impl->observer->on_group_subject_changed(new_subject, actor, when);
 }
 
 void messaging::GroupManager::announce_members_updated(const Members& members)

=== modified file 'src/messaging/has_interfaces.cpp'
--- src/messaging/has_interfaces.cpp	2016-03-30 19:19:19 +0000
+++ src/messaging/has_interfaces.cpp	2016-09-17 21:47:53 +0000
@@ -36,5 +36,12 @@
 void messaging::HasInterfaces::plug_interface(const std::shared_ptr<Interface>& interface)
 {
     impl->interfaces.insert(interface);
-}
-
+
+    interface->on_plugged(shared_from_this());
+    on_interface_plugged(interface);
+}
+
+void messaging::HasInterfaces::on_interface_plugged(const std::shared_ptr<Interface> &/*interface*/)
+{
+    // left empty on purpose
+}

=== modified file 'src/messaging/qt/tp/connection.cpp'
--- src/messaging/qt/tp/connection.cpp	2016-08-24 21:51:07 +0000
+++ src/messaging/qt/tp/connection.cpp	2016-09-17 21:47:53 +0000
@@ -22,6 +22,7 @@
 #include <messaging/qt/tp/interfaces/base_channel_destroyable.h>
 #include <messaging/qt/tp/interfaces/base_channel_roles.h>
 
+#include <messaging/broadcast.h>
 #include <messaging/message.h>
 #include <messaging/presence_status_not_supported.h>
 #include <messaging/user.h>
@@ -593,7 +594,6 @@
             {
                 std::shared_ptr<GroupStarter> group_starter = connection->group_starter();
                 group_manager = group_starter->accept_group(group);
-
                 if (group_manager->group_id().empty())
                 {
                     LOG(ERROR) << "Group creation rejected";
@@ -601,14 +601,20 @@
                     return Tp::BaseChannelPtr{};
                 }
 
-                // update recipient with id, title and members
+                // update recipient with id, title, creator, members and additional properties
+                // FIXME(rmescandon): a refactor is needed to move all this to a group_manager->group() object
+                // and create a copy constructor for Group which can be populated with cached data when needed
+                auto additional_properties = group->additional_properties();
+                if (not group_manager->group_subject().empty()) {
+                    additional_properties[Group::SUBJECT] = std::make_shared<messaging::BoostVariant>(group_manager->group_subject());
+                }
                 auto members = group_manager->members();
                 recipient = std::make_shared<messaging::Group>(
                             group_manager->group_id(),
                             members,
                             group_manager->group_title(),
-                            group_manager->group_creator());
-
+                            group_manager->group_creator(),
+                            additional_properties);
             }
             catch (const std::exception &e)
             {
@@ -650,13 +656,20 @@
                     return Tp::BaseChannelPtr{};
                 }
 
-                // update recipient with id, title and members
+                // update recipient with id, title, creator, members and additional properties
+                // FIXME(rmescandon): a refactor is needed to move all this to a group_manager->group() object
+                // and create a copy constructor for Group which can be populated with cached data when needed
+                auto additional_properties = group->additional_properties();
+                if (not group_manager->group_subject().empty()) {
+                    additional_properties[Group::SUBJECT] = std::make_shared<messaging::BoostVariant>(group_manager->group_subject());
+                }
                 auto members = group_manager->members();
                 recipient = std::make_shared<messaging::Group>(
                             group_manager->group_id(),
                             members,
                             group_manager->group_title(),
-                            group_manager->group_creator());
+                            group_manager->group_creator(),
+                            additional_properties);
             }
             catch (const std::exception &e)
             {
@@ -673,11 +686,15 @@
             break;
         }
         case Tp::HandleTypeNone: {
-            // This is the case of creating a group from the app. There is not type for the handle of the channel to be created when
+            bool is_room = hints.contains(TP_QT_IFACE_CHANNEL_INTERFACE_ROOM + QLatin1String(".RoomName"));
+
+            // There are two possible cases in which handle type is going to be none: chat rooms and broadcast channels.
+            // For broadcast channels the handle type will remain as none during the entire channel lifetime. For chat rooms
+            // once the creation is finished, the type will change to room.
+            // For the chat room case, this code will be called when creating a group from the app.
+            // There is not type for the handle of the channel to be created when
             // received the request. We have to switch to Room type and get the provided information
-
             messaging::Members initial_invitees;
-            std::string title;
             if (hints.contains(TP_QT_IFACE_CHANNEL_INTERFACE_CONFERENCE + QLatin1String(".InitialInviteeIDs")))
             {
                 QStringList initial_invitees_ids =
@@ -698,73 +715,91 @@
                     //FIXME: get contact attribute display name for the user second param
                     //FIXME: consider here if needed to provide initial roles to members
                     initial_invitees.push_back(std::make_shared<Member>(normalized_id,
-                                                                        PendingStatus::Remote,
+                                                                        is_room ? PendingStatus::Remote : PendingStatus::None,
                                                                         Flags<Role>(Role::Member),
                                                                         std::string{}/* display_name*/ ));
                 }
             }
 
-            if (hints.contains(TP_QT_IFACE_CHANNEL_INTERFACE_ROOM_CONFIG + QLatin1String(".Title")))
-            {
-                title = hints[TP_QT_IFACE_CHANNEL_INTERFACE_ROOM_CONFIG + QLatin1String(".Title")].toString().toStdString();
-            }
-
             // check if the client requested a chat room
-            if (hints.contains(TP_QT_IFACE_CHANNEL_INTERFACE_ROOM + QLatin1String(".RoomName")))
+            // if so, create the group related stuff
+            if (is_room)
             {
                 target_handle_type = Tp::HandleTypeRoom;
-            }
-
-            std::string initiator_handle;
-            if (hints.contains(TP_QT_IFACE_CHANNEL + QLatin1String(".InitiatorHandle")))
-            {
-                initiator_handle = hints[TP_QT_IFACE_CHANNEL + QLatin1String(".InitiatorHandle")].toString().toStdString();
-            }
-
-            //FIXME: fill group title parameter when got somehow
-            // create initial group recipient with no identifier for plugin to create the group
-            recipient = std::make_shared<messaging::Group>(
-                        std::string{} /* no id exists yet */,
-                        initial_invitees,
-                        title,
-                        std::make_shared<messaging::Member>(initiator_handle));
-
-            try
-            {
-                std::shared_ptr<GroupStarter> group_starter = connection->group_starter();
-                messaging::Group::shared_ptr group = std::dynamic_pointer_cast<messaging::Group>(recipient);
-                group_manager = group_starter->create_group(group);
-
-                if (group_manager->group_id().empty())
+
+                std::string title;
+                auto additional_properties = VariantMap{};
+
+                if (hints.contains(TP_QT_IFACE_CHANNEL_INTERFACE_ROOM_CONFIG + QLatin1String(".Title")))
+                {
+                    title = hints[TP_QT_IFACE_CHANNEL_INTERFACE_ROOM_CONFIG + QLatin1String(".Title")].toString().toStdString();
+                }
+
+                std::string initiator_handle;
+                if (hints.contains(TP_QT_IFACE_CHANNEL + QLatin1String(".InitiatorHandle")))
+                {
+                    initiator_handle = hints[TP_QT_IFACE_CHANNEL + QLatin1String(".InitiatorHandle")].toString().toStdString();
+                }
+
+                if (hints.contains(TP_QT_IFACE_CHANNEL_INTERFACE_SUBJECT + QLatin1String(".Subject")))
+                {
+                    additional_properties[Group::SUBJECT] =
+                            std::make_shared<messaging::BoostVariant>(
+                                hints[TP_QT_IFACE_CHANNEL_INTERFACE_SUBJECT + QLatin1String(".Subject")].toString().toStdString());
+                }
+
+                // create initial group recipient with no identifier for plugin to create the group
+                recipient = std::make_shared<messaging::Group>(
+                            std::string{} /* no id exists yet */,
+                            initial_invitees,
+                            title,
+                            std::make_shared<messaging::Member>(initiator_handle),
+                            additional_properties);
+                try
+                {
+                    std::shared_ptr<GroupStarter> group_starter = connection->group_starter();
+                    messaging::Group::shared_ptr group = std::dynamic_pointer_cast<messaging::Group>(recipient);
+                    group_manager = group_starter->create_group(group);
+
+                    if (group_manager->group_id().empty())
+                    {
+                        LOG(ERROR) << "Group creation rejected";
+                        error->set(TP_QT_ERROR_CANCELLED, "Group creation rejected");
+                        return Tp::BaseChannelPtr{};
+                    }
+
+                    // update recipient with id, title, members and additional properties
+                    auto additional_properties = group->additional_properties();
+                    if (not group_manager->group_subject().empty()) {
+                        additional_properties[Group::SUBJECT] = std::make_shared<messaging::BoostVariant>(group_manager->group_subject());
+                    }
+                    recipient = std::make_shared<messaging::Group>(
+                                group_manager->group_id(),
+                                group_manager->members(),
+                                group_manager->group_title(),
+                                group_manager->group_creator(),
+                                additional_properties);
+                }
+                catch (const std::exception &e)
+                {
+                    LOG(ERROR) << "Group creation rejected, " << e.what();
+                    error->set(TP_QT_ERROR_CANCELLED, "Group creation rejected");
+                    return Tp::BaseChannelPtr{};
+                }
+                catch (...)
                 {
                     LOG(ERROR) << "Group creation rejected";
                     error->set(TP_QT_ERROR_CANCELLED, "Group creation rejected");
                     return Tp::BaseChannelPtr{};
                 }
 
-                // update recipient with id, title and members
-                recipient = std::make_shared<messaging::Group>(
-                            group_manager->group_id(),
-                            group_manager->members(),
-                            group_manager->group_title(),
-                            group_manager->group_creator());
-            }
-            catch (const std::exception &e)
-            {
-                LOG(ERROR) << "Group creation rejected, " << e.what();
-                error->set(TP_QT_ERROR_CANCELLED, "Group creation rejected");
-                return Tp::BaseChannelPtr{};
-            }
-            catch (...)
-            {
-                LOG(ERROR) << "Group creation rejected";
-                error->set(TP_QT_ERROR_CANCELLED, "Group creation rejected");
-                return Tp::BaseChannelPtr{};
-            }
-
-            // request handle from group_manager id, filled with the group id after calling start_group()
-            Tp::DBusError error;
-            target_handle = request_handles(Tp::HandleTypeRoom, QStringList() << QString::fromStdString(group_manager->group_id()), &error)[0];
+                // request handle from group_manager id, filled with the group id after calling start_group()
+                Tp::DBusError error;
+                target_handle = request_handles(Tp::HandleTypeRoom, QStringList() << QString::fromStdString(group_manager->group_id()), &error)[0];
+            } else {
+                // if not, consider this a broadcast channel
+                recipient = std::make_shared<messaging::Broadcast>(initial_invitees);
+            }
             break;
         }
         default:

=== modified file 'src/messaging/qt/tp/interfaces/base_channel_roles.cpp'
--- src/messaging/qt/tp/interfaces/base_channel_roles.cpp	2016-08-12 13:19:22 +0000
+++ src/messaging/qt/tp/interfaces/base_channel_roles.cpp	2016-09-17 21:47:53 +0000
@@ -148,7 +148,7 @@
     }
 
     if (!canUpdateRoles()) {
-        error->set(TP_QT_ERROR_PERMISSION_DENIED, QLatin1String("Operation not allowed; anUpdateRoles flag set to false"));
+        error->set(TP_QT_ERROR_PERMISSION_DENIED, QLatin1String("Operation not allowed; canUpdateRoles flag set to false"));
     }
 
     return mPriv->updateRolesCB(contactRoles, error);

=== added file 'src/messaging/qt/tp/interfaces/base_channel_subject.cpp'
--- src/messaging/qt/tp/interfaces/base_channel_subject.cpp	1970-01-01 00:00:00 +0000
+++ src/messaging/qt/tp/interfaces/base_channel_subject.cpp	2016-09-17 21:47:53 +0000
@@ -0,0 +1,205 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <TelepathyQt/DBusObject>
+#include <messaging/qt/tp/interfaces/base_channel_subject.h>
+#include <messaging/qt/tp/interfaces/base_channel_subject_internal.h>
+
+namespace mqti = messaging::qt::tp::interfaces;
+
+// Chan.I.Subject
+mqti::BaseChannelSubjectInterface::Adaptee::Adaptee(BaseChannelSubjectInterface *interface)
+    : QObject(interface),
+      mInterface(interface)
+{
+}
+
+mqti::BaseChannelSubjectInterface::Adaptee::~Adaptee()
+{
+}
+
+struct TP_QT_NO_EXPORT mqti::BaseChannelSubjectInterface::Private {
+    Private(BaseChannelSubjectInterface *parent)
+        :adaptee(new BaseChannelSubjectInterface::Adaptee(parent)) {
+    }
+
+    QString subject;
+    QString actor;
+    uint actorHandle;
+    qlonglong timestamp;
+    bool canSet;
+    SetSubjectCallback setSubjectCB;
+    BaseChannelSubjectInterface::Adaptee *adaptee;
+};
+
+QString mqti::BaseChannelSubjectInterface::Adaptee::subject() const
+{
+    return mInterface->subject();
+}
+
+QString mqti::BaseChannelSubjectInterface::Adaptee::actor() const
+{
+    return mInterface->actor();
+}
+
+uint mqti::BaseChannelSubjectInterface::Adaptee::actorHandle() const
+{
+    return mInterface->actorHandle();
+}
+
+qlonglong mqti::BaseChannelSubjectInterface::Adaptee::timestamp() const
+{
+    return mInterface->timestamp();
+}
+
+bool mqti::BaseChannelSubjectInterface::Adaptee::canSet() const
+{
+    return mInterface->canSet();
+}
+
+void mqti::BaseChannelSubjectInterface::Adaptee::setSubject(const QString &subject, const Tp::Service::ChannelInterfaceSubjectAdaptor::SetSubjectContextPtr &context)
+{
+    if (!mInterface->mPriv->setSubjectCB.isValid()) {
+        context->setFinishedWithError(TP_QT_ERROR_NOT_IMPLEMENTED, QLatin1String("Not implemented"));
+        return;
+    }
+
+    Tp::DBusError error;
+    mInterface->mPriv->setSubjectCB(subject, &error);
+    if (error.isValid()) {
+        context->setFinishedWithError(error.name(), error.message());
+        return;
+    }
+    context->setFinished();
+}
+
+/**
+ * \class BaseChannelSubjectInterface
+ *
+ * \brief Base class for implementations of Channel.Interface.Subject
+ *
+ */
+
+/**
+ * Class constructor.
+ */
+mqti::BaseChannelSubjectInterface::BaseChannelSubjectInterface()
+    : Tp::AbstractChannelInterface(TP_QT_IFACE_CHANNEL_INTERFACE_SUBJECT),
+      mPriv(new Private(this))
+{
+}
+
+void mqti::BaseChannelSubjectInterface::setSetSubjectCallback(const SetSubjectCallback &cb)
+{
+    mPriv->setSubjectCB = cb;
+}
+
+/**
+ * Class destructor.
+ */
+mqti::BaseChannelSubjectInterface::~BaseChannelSubjectInterface()
+{
+    delete mPriv;
+}
+
+/**
+ * Return the immutable properties of this interface.
+ *
+ * Immutable properties cannot change after the interface has been registered
+ * on a service on the bus with registerInterface().
+ *
+ * \return The immutable properties of this interface.
+ */
+QVariantMap mqti::BaseChannelSubjectInterface::immutableProperties() const
+{
+    QVariantMap map;
+    return map;
+}
+
+void mqti::BaseChannelSubjectInterface::createAdaptor()
+{
+    (void) new Tp::Service::ChannelInterfaceSubjectAdaptor(dbusObject()->dbusConnection(),
+            mPriv->adaptee, dbusObject());
+}
+
+void mqti::BaseChannelSubjectInterface::setSubject(const QString &subject, Tp::DBusError *error)
+{
+    if (!mPriv->setSubjectCB.isValid()) {
+        error->set(TP_QT_ERROR_NOT_IMPLEMENTED, QLatin1String("Not implemented"));
+        return;
+    }
+
+    if (!canSet()) {
+        error->set(TP_QT_ERROR_PERMISSION_DENIED, QLatin1String("Operation not allowed; canSet flag set to false"));
+    }
+
+    return mPriv->setSubjectCB(subject, error);
+}
+
+QString mqti::BaseChannelSubjectInterface::subject() const
+{
+    return mPriv->subject;
+}
+
+void mqti::BaseChannelSubjectInterface::setSubject(const QString &subject)
+{
+    mPriv->subject = subject;
+    notifyPropertyChanged(QLatin1String("Subject"), QVariant::fromValue(subject));
+}
+
+QString mqti::BaseChannelSubjectInterface::actor() const
+{
+    return mPriv->actor;
+}
+
+void mqti::BaseChannelSubjectInterface::setActor(const QString &actor)
+{
+    mPriv->actor = actor;
+    notifyPropertyChanged(QLatin1String("Actor"), QVariant::fromValue(actor));
+}
+
+uint mqti::BaseChannelSubjectInterface::actorHandle() const
+{
+    return mPriv->actorHandle;
+}
+
+void mqti::BaseChannelSubjectInterface::setActorHandle(uint handle)
+{
+    mPriv->actorHandle = handle;
+    notifyPropertyChanged(QLatin1String("ActorHandle"), QVariant::fromValue(handle));
+}
+
+qlonglong mqti::BaseChannelSubjectInterface::timestamp() const
+{
+    return mPriv->timestamp;
+}
+
+void mqti::BaseChannelSubjectInterface::setTimestamp(qlonglong timestamp)
+{
+    mPriv->timestamp = timestamp;
+    notifyPropertyChanged(QLatin1String("Timestamp"), QVariant::fromValue(timestamp));
+}
+
+bool mqti::BaseChannelSubjectInterface::canSet() const
+{
+    return mPriv->canSet;
+}
+
+void mqti::BaseChannelSubjectInterface::setCanSet(bool canSet)
+{
+    mPriv->canSet = canSet;
+    notifyPropertyChanged(QLatin1String("CanSet"), QVariant::fromValue(canSet));
+}

=== modified file 'src/messaging/qt/tp/text_channel.cpp'
--- src/messaging/qt/tp/text_channel.cpp	2016-08-30 18:46:08 +0000
+++ src/messaging/qt/tp/text_channel.cpp	2016-09-17 21:47:53 +0000
@@ -21,6 +21,7 @@
 
 #include <messaging/qt/variant.h>
 
+#include <messaging/broadcast.h>
 #include <messaging/connection.h>
 #include <messaging/group.h>
 #include <messaging/messenger.h>
@@ -181,13 +182,21 @@
         });
 }
 
-void mqt::tp::TextChannel::Observer::on_group_title_changed(const std::string &new_title,
-                                                            const Member& actor,
-                                                            const std::chrono::system_clock::time_point& when)
-{
-    auto thiz = shared_from_this();
-    runtime->enter_with_task([thiz, new_title, actor, when]() {
-            thiz->tc->on_group_title_changed(new_title, actor, when);
+void mqt::tp::TextChannel::Observer::on_group_title_changed(const std::string &new_title)
+{
+    auto thiz = shared_from_this();
+    runtime->enter_with_task([thiz, new_title]() {
+            thiz->tc->on_group_title_changed(new_title);
+        });
+}
+
+void mqt::tp::TextChannel::Observer::on_group_subject_changed(const std::string &new_subject,
+                                                              const std::shared_ptr<Member>& actor,
+                                                              const std::chrono::system_clock::time_point& when)
+{
+    auto thiz = shared_from_this();
+    runtime->enter_with_task([thiz, new_subject, actor, when]() {
+            thiz->tc->on_group_subject_changed(new_subject, actor, when);
         });
 }
 
@@ -322,6 +331,27 @@
             return;
         }
 
+        // NOTE (rmescandon): Build and populate values for Subject interface before than roomConfig one. This is needed for having
+        // available subject Actor before setting the title in room config. That way, same value could be taken as actor for subject
+        // and title in upper layers
+        subject_interface = interfaces::BaseChannelSubjectInterface::create();
+        subject_interface->setActor(QString::fromStdString(group->creator()->id()));
+        subject_interface->setActorHandle(creator_handle);
+        subject_interface->setTimestamp(static_cast<qlonglong>(std::chrono::system_clock::to_time_t(std::chrono::system_clock::now())));
+
+        try
+        {
+            subject_interface->setCanSet(group_manager->permissions().is_set(GroupPermissions::CanChangeSubject));
+            // the last thing to set is the subject itself. This way, all the properties should be available in client
+            // for composing all the information like "%Actor% set subject to %Subject%"
+            subject_interface->setSubject(QString::fromStdString(group_manager->group_subject()));
+        }
+        catch (...)
+        {
+            LOG(ERROR) << "An exception has been thrown when setting group title as channel subject";
+            return;
+        }
+
         // uncomment the following code when room name is part of messaging::Group
         //QString roomName = QString::fromStdString(group->id());
         room_interface = Tp::BaseChannelRoomInterface::create(/* roomName */ QString(),
@@ -343,8 +373,8 @@
 
         room_config_interface->setConfigurationRetrieved(true);
 
-        // FIXME (rmescandon): as telepathy does not offer a way to differentiate whether it can be changed one configuration element
-        // or other, let's use the flag to enable/dissable all configuration properties permissions by now
+        // As telepathy does not offer a way to differentiate whether it can be changed one configuration element
+        // or other, let's use the flag to enable/dissable all configuration properties permissions
         room_config_interface->setCanUpdateConfiguration(group_manager->permissions().is_set(GroupPermissions::CanChangeTitle));
 
         // FIXME: check what flags we want by default
@@ -366,6 +396,24 @@
         // we need to set the initial group members
         on_members_updated(group->initial_invitees());
     }
+    else if (recipient->type() == RecipientType::broadcast)
+    {
+        messaging::Broadcast::shared_ptr broadcast = std::dynamic_pointer_cast<messaging::Broadcast>(recipient);
+        // for broadcast channels we just need to plug the group interface with limited capabilities
+        Tp::ChannelGroupFlags groupFlags = Tp::ChannelGroupFlagHandleOwnersNotAvailable |
+                                           Tp::ChannelGroupFlagMembersChangedDetailed |
+                                           Tp::ChannelGroupFlagProperties;
+        group_interface = Tp::BaseChannelGroupInterface::create();
+        group_interface->setGroupFlags(groupFlags);
+
+        // we need to plug this interface here to avoid a crash
+        plug_interface_if_available(group_interface);
+
+        destroyable_interface = mqt::tp::interfaces::BaseChannelDestroyableInterface::create();
+
+        // we need to set the initial group members
+        on_members_updated(broadcast->members());
+    }
 
     chat_state_interface = Tp::BaseChannelChatStateInterface::create();
 
@@ -588,7 +636,6 @@
         LOG(ERROR) << "An exception has been thrown when setting group self handle";
         return;
     }
-
 }
 
 void mqt::tp::TextChannel::close_channel_with_reason(uint reason, const QString &message)
@@ -662,22 +709,42 @@
     close_channel_with_reason(reason, message);
 }
 
-void mqt::tp::TextChannel::on_group_title_changed(const std::string &new_title,
-                                                  const Member& actor,
-                                                  const std::chrono::system_clock::time_point& when)
+void mqt::tp::TextChannel::on_group_title_changed(const std::string &new_title)
 {
-    //TODO(rmescandon): must be implemented interface Subject2 in order to use parameters actor and when
-    // (see https://telepathy.freedesktop.org/spec/Channel_Interface_Subject.html)
-    // meanwhile they are unused
-    Q_UNUSED(actor);
-    Q_UNUSED(when);
-
+    // for a flexible management in client, set as title both room_config title and subject
     if (room_config_interface)
     {
         room_config_interface->setTitle(QString::fromStdString(new_title));
     }
 }
 
+void mqt::tp::TextChannel::on_group_subject_changed(const std::string &new_subject,
+                                                    const std::shared_ptr<Member>& actor,
+                                                    const std::chrono::system_clock::time_point& when)
+{
+    if (subject_interface)
+    {
+        if (not actor->id().empty())
+        {
+            Tp::DBusError error;
+            uint handle;
+            if (actor->id() == "me") {
+                handle = tp_connection->selfHandle();
+            } else {
+                handle = tp_connection->requestHandles(Tp::HandleTypeContact, QStringList() << QString::fromStdString(actor->id()), &error)[0];
+            }
+            // set always the actor before the subject, for having it available in client when subject is available
+            subject_interface->setActor(QString::fromStdString(actor->id()));
+            subject_interface->setActorHandle(handle);
+        }
+
+        subject_interface->setTimestamp(static_cast<qlonglong>(std::chrono::system_clock::to_time_t(when)));
+        // the last thing to set is the subject itself. This way, all the properties should be available in client
+        // for composing all the information like "%Actor% set subject to %Subject%"
+        subject_interface->setSubject(QString::fromStdString(new_subject));
+    }
+}
+
 void mqt::tp::TextChannel::on_members_updated(const Members& received_members)
 {
     LOG(INFO) << __PRETTY_FUNCTION__;
@@ -778,6 +845,11 @@
         room_config_interface->setCanUpdateConfiguration(permissions.is_set(GroupPermissions::CanChangeTitle));
     }
 
+    if (not subject_interface.isNull())
+    {
+        subject_interface->setCanSet(permissions.is_set(GroupPermissions::CanChangeTitle));
+    }
+
     // Can kick other participants?
     if (not group_interface.isNull())
     {
@@ -966,6 +1038,11 @@
         return;
     }
 
+    set_subject(properties["Title"].toString(), error);
+}
+
+void mqt::tp::TextChannel::set_subject(const QString &subject, Tp::DBusError *error)
+{
     try
     {
         std::shared_ptr<messaging::GroupManager> group_manager = chat->interface<GroupManager>();
@@ -979,11 +1056,11 @@
             return;
         }
 
-        group_manager->change_group_title(properties["Title"].toString().toStdString());
+        group_manager->change_group_title(subject.toStdString());
     }
     catch (...)
     {
-        LOG(ERROR) << "An exception has been thrown when updating group configuration";
+        LOG(ERROR) << "An exception has been thrown when setting subject";
     }
 }
 
@@ -1081,6 +1158,11 @@
     {
         roles_interface->setUpdateRolesCallback(Tp::memFun(this, &TextChannel::update_roles));
     }
+
+    if (!subject_interface.isNull())
+    {
+        subject_interface->setSetSubjectCallback(Tp::memFun(this, &TextChannel::set_subject));
+    }
 }
 
 void mqt::tp::TextChannel::plug_interfaces_once()
@@ -1092,6 +1174,7 @@
     plug_interface_if_available(chat_state_interface);
     plug_interface_if_available(destroyable_interface);
     plug_interface_if_available(roles_interface);
+    plug_interface_if_available(subject_interface);
 }
 
 void mqt::tp::TextChannel::plug_interface_if_available(const Tp::AbstractChannelInterfacePtr &interface)

=== modified file 'tests/mock_group_manager.h'
--- tests/mock_group_manager.h	2016-08-17 15:04:16 +0000
+++ tests/mock_group_manager.h	2016-09-17 21:47:53 +0000
@@ -34,19 +34,23 @@
         MOCK_METHOD1(on_group_created, void(const std::string& id));
         MOCK_METHOD0(on_group_cancelled, void());
         MOCK_METHOD1(on_group_title_changed, void(const std::string&));
+        MOCK_METHOD3(on_group_subject_changed, void(const std::string&, const std::shared_ptr<messaging::Member>&, const std::chrono::system_clock::time_point&));
     };
 
     MOCK_METHOD0(leave_group, void());
     MOCK_METHOD0(dissolve_group, void());
     MOCK_METHOD0(join_group, void());
     MOCK_METHOD1(change_group_title, void(const std::string&));
+    MOCK_METHOD1(change_group_subject, void(const std::string&));
     MOCK_METHOD1(add_members, void(const messaging::Members&));
     MOCK_METHOD1(remove_members, void(const messaging::Members&));
     MOCK_METHOD0(group_id, std::string());
     MOCK_METHOD0(group_title, std::string());
+    MOCK_METHOD0(group_subject, std::string());
     MOCK_METHOD0(group_creator, std::shared_ptr<messaging::Member>());
     MOCK_METHOD0(members, messaging::Members());
     MOCK_METHOD1(set_observer, void(const std::shared_ptr<Observer>&));
+    MOCK_METHOD1(on_plugged, void(const std::weak_ptr<messaging::HasInterfaces>&));
 };
 
 }