Ticket #11922: 0010-Add-support-to-BMediaRoster-for-B_MEDIA_SERVER_START.patch

headers/os/media/MediaDefs.h

@@ -47 +47 @@
     B_MEDIA_NEW_PARAMETER_VALUE,    /* N "node", "parameter", "when", */
                                     /* "value" */
     B_MEDIA_NODE_STOPPED,           /* N "node", "when" */
-    B_MEDIA_FLAVORS_CHANGED         /* "be:addon_id", "be:new_count", */
+    B_MEDIA_FLAVORS_CHANGED,        /* "be:addon_id", "be:new_count", */
                                     /* "be:gone_count" */
+    B_MEDIA_SERVER_STARTED,
+    B_MEDIA_SERVER_QUIT
 };
 
 

headers/private/media/DataExchange.h

@@ -16 +16 @@
 namespace dataexchange {
 
 
-void InitDataExchange();
+void InitServerDataExchange();
+void InitRosterDataExchange(const BMessenger& rosterMessenger);
+
+// BMessage based data exchange with the current BMediaRoster
+status_t SendToRoster(BMessage* msg);
 
 // BMessage based data exchange with the media_server
 status_t SendToServer(BMessage* msg);

headers/private/media/MediaRosterEx.h

@@ -87 +87 @@
 
     BTimeSource*        MakeTimeSourceObject(media_node_id timesource_id);
 
+    // Build the connection with the media_server
+    status_t            BuildConnections();
+
 private:
     friend class BMediaRoster;
 };

headers/private/media/ServerInterface.h

@@ -32 +32 @@
     MEDIA_ADD_ON_SERVER_PLAY_MEDIA = '_TRU'
 };
 
+enum {
+    // local media services status notification service
+    MEDIA_ROSTER_REQUEST_NOTIFICATIONS = 2000,
+    MEDIA_ROSTER_CANCEL_NOTIFICATIONS
+};
+
 // Raw port based communication
 enum {
     GENERAL_PURPOSE_WAKEUP = 0, // when no action but wait termination needed

src/kits/media/DataExchange.cpp

@@ -25 +25 @@
 
 
 static BMessenger sMediaServerMessenger;
+static BMessenger sMediaRosterMessenger;
 static port_id sMediaServerPort;
 static port_id sMediaAddonServerPort;
 
@@ -58 +59 @@
 
 
 void
-InitDataExchange()
+InitServerDataExchange()
 {
     sMediaServerMessenger = BMessenger(B_MEDIA_SERVER_SIGNATURE);
     find_media_server_port();
@@ -66 +67 @@
 }
 
 
+void
+InitRosterDataExchange(const BMessenger& rosterMessenger)
+{
+    sMediaRosterMessenger = rosterMessenger;
+}
+
+
+//! BMessage based data exchange with the local BMediaRoster
+status_t
+SendToRoster(BMessage* msg)
+{
+    status_t status = sMediaRosterMessenger.SendMessage(msg,
+        static_cast<BHandler*>(NULL), TIMEOUT);
+    if (status != B_OK) {
+        ERROR("SendToRoster: SendMessage failed: %s\n", strerror(status));
+        DEBUG_ONLY(msg->PrintToStream());
+    }
+    return status;
+}
+
+
 //! BMessage based data exchange with the media_server
 status_t
 SendToServer(BMessage* msg)

src/kits/media/MediaRoster.cpp

@@ -67 +67 @@
 #include <Notifications.h>
 #include <ServerInterface.h>
 #include <SharedBufferList.h>
+#include <TList.h>
 
 #include "TimeSourceObjectManager.h"
 
@@ -75 +76 @@
 namespace media {
 
 
+struct RosterNotification {
+    BMessenger  messenger;
+    int32       what;
+};
+
+static bool sServerIsUp = false;
+static List<RosterNotification> sNotificationList;
+
 class MediaInitializer {
 public:
     MediaInitializer()
     {
-        InitDataExchange();
+        InitServerDataExchange();
     }
 
     ~MediaInitializer()
@@ -105 +114 @@
     :
     BMediaRoster()
 {
-    InitDataExchange();
-
     gDormantNodeManager = new DormantNodeManager;
     gTimeSourceObjectManager = new TimeSourceObjectManager;
 
+    *_error = BuildConnections();
+
+    InitRosterDataExchange(BMessenger(this, this));
+
+    if (be_roster->StartWatching(BMessenger(this, this),
+        B_REQUEST_LAUNCHED | B_REQUEST_QUIT) != B_OK)
+            *_error = B_ERROR;
+
+    sServerIsUp = BMediaRoster::IsRunning();
+}
+
+
+status_t
+BMediaRosterEx::BuildConnections()
+{
+    InitServerDataExchange();
+
     // register this application with the media server
     server_register_app_request request;
     server_register_app_reply reply;
@@ -118 +142 @@
 
     status_t status = QueryServer(SERVER_REGISTER_APP, &request,
         sizeof(request), &reply, sizeof(reply));
+
     if (status != B_OK)
-        *_error = B_MEDIA_SYSTEM_FAILURE;
+        return B_MEDIA_SYSTEM_FAILURE;
     else
-        *_error = B_OK;
+        return B_OK;
 }
 
 
@@ -1870 +1895 @@
         ERROR("BMediaRoster::StartWatching: messenger invalid!\n");
         return B_BAD_VALUE;
     }
+
     return BPrivate::media::notifications::Register(where, media_node::null,
         B_MEDIA_WILDCARD);
 }
@@ -1888 +1914 @@
         ERROR("BMediaRoster::StartWatching: notificationType invalid!\n");
         return B_BAD_VALUE;
     }
+
+    // NOTE: we support only explicitly B_MEDIA_SERVER_STARTED/QUIT
+    // notifications. This should be cleared in documentation.
+
     return BPrivate::media::notifications::Register(where, media_node::null,
         notificationType);
 }
@@ -3253 +3283 @@
             return;
         }
 
+        case MEDIA_ROSTER_REQUEST_NOTIFICATIONS:
+        {
+            RosterNotification notification;
+            if (message->FindInt32(NOTIFICATION_PARAM_WHAT, &notification.what)
+                != B_OK) {
+                TRACE("BMediaRoster MEDIA_ROSTER_REQUEST_NOTIFICATIONS can't"
+                    "find what parameter");
+                return;
+            }
+            if (message->FindMessenger(NOTIFICATION_PARAM_MESSENGER,
+                &notification.messenger) != B_OK) {
+                TRACE("BMediaRoster MEDIA_ROSTER_REQUEST_NOTIFICATIONS can't"
+                    "find messenger");
+                return;
+            }
+            sNotificationList.Insert(notification);
+            return;
+        }
+
+        case MEDIA_ROSTER_CANCEL_NOTIFICATIONS:
+        {
+            RosterNotification notification;
+            if (message->FindInt32(NOTIFICATION_PARAM_WHAT, &notification.what)
+                != B_OK) {
+                TRACE("BMediaRoster MEDIA_ROSTER_CANCEL_NOTIFICATIONS can't"
+                    "find what parameter");
+                return;
+            }
+            if (message->FindMessenger(NOTIFICATION_PARAM_MESSENGER,
+                &notification.messenger) != B_OK) {
+                TRACE("BMediaRoster MEDIA_ROSTER_CANCEL_NOTIFICATIONS can't"
+                    "find messenger");
+                return;
+            }
+            for (int32 i = 0; i < sNotificationList.CountItems(); i++) {
+                RosterNotification* current;
+                if (sNotificationList.Get(i, &current) != true)
+                    return;
+                if (current->what == notification.what
+                    && current->messenger == notification.messenger) {
+                    sNotificationList.Remove(i);
+                    return;
+                }
+            }
+            return;
+        }
+
+        case B_SOME_APP_LAUNCHED:
+        {
+            BString mimeSig;
+            if (message->FindString("be:signature", &mimeSig) != B_OK)
+                return;
+            if (mimeSig != B_MEDIA_ADDON_SERVER_SIGNATURE
+                    && mimeSig != B_MEDIA_SERVER_SIGNATURE)
+                return;
+
+            TRACE("BMediaRoster::MessageReceived media services are going up.");
+
+            // Send the notification to our subscribers
+            if (BMediaRoster::IsRunning()) {
+                sServerIsUp = true;
+                // Restore our friendship with the media servers
+                if (MediaRosterEx(this)->BuildConnections() != B_OK) {
+                    TRACE("BMediaRoster::MessageReceived can't reconnect"
+                        "to media_server.");
+                }
+
+                for (int32 i = 0; i < sNotificationList.CountItems(); i++) {
+                    RosterNotification* current;
+                    if (sNotificationList.Get(i, &current) != true)
+                        return;
+                    if (current->what == B_MEDIA_SERVER_STARTED) {
+                        if (current->messenger.SendMessage(
+                            B_MEDIA_SERVER_STARTED) != B_OK) {
+                            if(!current->messenger.IsValid())
+                                sNotificationList.Remove(i);
+                        }
+                    }
+                }
+            }
+            return;
+        }
+
+        case B_SOME_APP_QUIT:
+        {
+            BString mimeSig;
+            if (message->FindString("be:signature", &mimeSig) != B_OK)
+                return;
+            if (mimeSig != B_MEDIA_ADDON_SERVER_SIGNATURE
+                    && mimeSig != B_MEDIA_SERVER_SIGNATURE)
+                return;
+
+            TRACE("BMediaRoster::MessageReceived media services are down.");
+
+            // Send the notification to our subscribers
+            if (!BMediaRoster::IsRunning() && sServerIsUp == true) {
+                sServerIsUp = false;
+                for (int32 i = 0; i < sNotificationList.CountItems(); i++) {
+                    RosterNotification* current;
+                    if (sNotificationList.Get(i, &current) != true)
+                        return;
+                    if (current->what == B_MEDIA_SERVER_QUIT) {
+                        if (current->messenger.SendMessage(
+                            B_MEDIA_SERVER_QUIT) != B_OK) {
+                            if(!current->messenger.IsValid())
+                                sNotificationList.Remove(i);
+                        }
+                    }
+                }
+            }
+            return;
+        }
+
         case NODE_FINAL_RELEASE:
         {
             // this function is called by a BMediaNode to delete
@@ -3322 +3465 @@
     // Unset the global instance pointer, the destructor is also called
     // if a client app calls Lock(); and Quit(); directly.
     sDefaultInstance = NULL;
+    if (sNotificationList.CountItems() != 0)
+        sNotificationList.MakeEmpty();
+
+    if (be_roster->StopWatching(BMessenger(this, this)) != B_OK)
+            TRACE("Can't unregister roster notifications");
 }
 
 

src/kits/media/Notifications.cpp

@@ -58 +58 @@
     int32 notification)
 {
     CALLED();
+
+    if (notification == B_MEDIA_SERVER_STARTED
+        || notification == B_MEDIA_SERVER_QUIT) {
+        BMessage msg(MEDIA_ROSTER_REQUEST_NOTIFICATIONS);
+        msg.AddInt32(NOTIFICATION_PARAM_WHAT, notification);
+        msg.AddMessenger(NOTIFICATION_PARAM_MESSENGER, notifyHandler);
+        return BPrivate::media::dataexchange::SendToRoster(&msg);
+    }
+
     BMessage msg(MEDIA_SERVER_REQUEST_NOTIFICATIONS);
     msg.AddInt32(NOTIFICATION_PARAM_WHAT, notification);
     msg.AddInt32(NOTIFICATION_PARAM_TEAM, BPrivate::current_team());
@@ -73 +82 @@
     int32 notification)
 {
     CALLED();
+
+    if (notification == B_MEDIA_SERVER_STARTED
+        || notification == B_MEDIA_SERVER_QUIT) {
+        BMessage msg(MEDIA_ROSTER_CANCEL_NOTIFICATIONS);
+        msg.AddInt32(NOTIFICATION_PARAM_WHAT, notification);
+        msg.AddMessenger(NOTIFICATION_PARAM_MESSENGER, notifyHandler);
+        return BPrivate::media::dataexchange::SendToRoster(&msg);
+    }
+
     BMessage msg(MEDIA_SERVER_CANCEL_NOTIFICATIONS);
     msg.AddInt32(NOTIFICATION_PARAM_WHAT, notification);
     msg.AddInt32(NOTIFICATION_PARAM_TEAM, BPrivate::current_team());
@@ -295 +313 @@
         case B_MEDIA_FLAVORS_CHANGED:
             return true;
 
+        // invalid if we watch for a specific node
+        case B_MEDIA_SERVER_STARTED:
+        case B_MEDIA_SERVER_QUIT:
+            return !node_specific;
+
         // only valid for node specific watching
         case B_MEDIA_PARAMETER_CHANGED:
         case B_MEDIA_FORMAT_CHANGED: