feat(recording): add presentation minize events to layout.xml

- Include the info when presentation is minimized by presenter with push layout on:

<?xml version="1.0" encoding="UTF-8"?>
<recording id="layout_swap_events">
  <event timestamp="0.0" show_screenshare="false"/>
  <event timestamp="6.0" show_screenshare="true"/>
  <event timestamp="12.7" show_screenshare="false"/>
  <event timestamp="19.7" show_presentation="true"/>
  <event timestamp="21.6" show_presentation="false"/>
  <event timestamp="24.8" show_presentation="true"/>
  <event timestamp="29.9" show_presentation="false"/>
</recording>

Author: germanocaumo

record-and-playback/core/lib/recordandplayback/generators/events.rb

@@ -1167,17 +1167,20 @@ def self.screenshare_has_audio?(events, deskshare_dir)
       return false
     end
 
-    # Get a list of times when the "screenshare as content" flag is changed
+    # Generic function to get a list of times when a specific state changes
     #
     # The returned times account for recording start/stop events, and have timestamps relative to the start of the
     # recording.
     #
     # @param events [Nokogiri::XML::Document] The parsed events.xml document
     # @param start_time [Integer] The recording segment start timestamp (ms)
     # @param end_time [Integer] The recording segment end timestamp (ms)
-    # @return [Array<Hash>] An array of events, each with a timestamp and the screenshareAsContent flag
-    def self.get_screenshare_as_content_events(events, start_time, end_time)
-      BigBlueButton.logger.info('Getting Screenshare as Content Events')
+    # @param target_module [String] The module name of the event to track
+    # @param target_eventname [String] The event name to track
+    # @param compare_keys [Array<Symbol>] Optional list of keys to compare for state changes. If nil, all keys are compared.
+    # @return [Array<Hash>] An array of events, each with a timestamp and the extracted state
+    def self.get_events(events, start_time, end_time, target_module, target_eventname, compare_keys = nil)
+      BigBlueButton.logger.info("Getting #{target_eventname} Events")
 
       initial_timestamp = first_event_timestamp(events)
       start_time -= initial_timestamp
@@ -1188,25 +1191,32 @@ def self.get_screenshare_as_content_events(events, start_time, end_time)
       # Recordings without status events are assumed to have been recorded from the beginning
       record = events.at_xpath('/recording/event[@eventname="RecordStatusEvent"]').nil?
 
-      screenshare_content_events = []
+      extracted_events = []
+      current_state = nil
 
       events.xpath('/recording/event').each do |event|
         timestamp = event[:timestamp].to_i - initial_timestamp
         break if timestamp >= end_time
 
         case [event[:module], event[:eventname]]
-        when %w[PARTICIPANT SetScreenshareAsContentEvent]
-          screenshare_as_content = event.at_xpath('screenshareAsContent')&.content == 'true'
+        when [target_module, target_eventname]
+          current_state = yield(event)
 
           # Don't emit events during unrecorded sections of the meeting. An event will be emitted when recording resumes
           next unless timestamp >= start_time && record
+          
           # Don't emit an event if the previous event has the same state
-          next if screenshare_content_events.dig(-1, :screenshareAsContent) == screenshare_as_content
+          if extracted_events.last
+            last_event = extracted_events.last.reject { |k| k == :timestamp }
+            if compare_keys
+              next if last_event.select { |k, _| compare_keys.include?(k) } == current_state.select { |k, _| compare_keys.include?(k) }
+            else
+              next if last_event == current_state
+            end
+          end
+
+          extracted_events << current_state.merge(timestamp: timestamp - offset)
 
-          screenshare_content_events << {
-            timestamp: timestamp - offset,
-            screenshareAsContent: screenshare_as_content,
-          }
         when %w[PARTICIPANT RecordStatusEvent]
           record = event.at_xpath('status').content == 'true'
           # Don't update timestamps until we're past the segment start time
@@ -1217,12 +1227,17 @@ def self.get_screenshare_as_content_events(events, start_time, end_time)
             offset += timestamp - last_stop_timestamp
 
             # Don't emit an event if the previous event has the same state
-            next if screenshare_content_events.dig(-1, :screenshareAsContent) == screenshare_as_content
+            next if current_state.nil?
+            if extracted_events.last
+              last_event = extracted_events.last.reject { |k| k == :timestamp }
+              if compare_keys
+                next if last_event.select { |k, _| compare_keys.include?(k) } == current_state.select { |k, _| compare_keys.include?(k) }
+              else
+                next if last_event == current_state
+              end
+            end
 
-            screenshare_content_events << {
-              timestamp: timestamp - offset,
-              screenshareAsContent: screenshare_as_content,
-            }
+            extracted_events << current_state.merge(timestamp: timestamp - offset)
           else
             # Recording paused
             last_stop_timestamp = timestamp
@@ -1232,18 +1247,36 @@ def self.get_screenshare_as_content_events(events, start_time, end_time)
           # whatever the state happened to be when start_time was reached
 
           # Don't emit an event during unrecorded sections of the meeting, or if one has already been emitted.
-          next unless timestamp >= start_time && record && screenshare_content_events.empty?
+          next unless timestamp >= start_time && record && extracted_events.empty?
 
-          # Don't emit an event if we haven't seen a SetScreenshareAsContentEvent yet
-          next if screenshare_as_content.nil?
+          # Don't emit an event if we haven't seen the target event yet
+          next if current_state.nil?
 
-          screenshare_content_events << {
-            timestamp: 0,
-            screenshareAsContent: screenshare_as_content,
-          }
+          extracted_events << current_state.merge(timestamp: 0)
         end
       end
-      screenshare_content_events
+      extracted_events
+    end
+
+    def self.get_screenshare_as_content_events(events, start_time, end_time)
+      get_events(events, start_time, end_time, 'PARTICIPANT', 'SetScreenshareAsContentEvent', [:screenshareAsContent]) do |event|
+        {
+          screenshareAsContent: event.at_xpath('screenshareAsContent')&.content == "true"
+        }
+      end
+    end
+
+    def self.get_layout_broadcasted_events(events, start_time, end_time)
+      get_events(events, start_time, end_time, 'PARTICIPANT', 'LayoutBroadcastedEvent', [:presentationIsOpen]) do |event|
+        {
+          focusedCamera: event.at_xpath('focusedCamera')&.content,
+          presentationVideoRate: event.at_xpath('presentationVideoRate')&.content.to_f,
+          cameraPosition: event.at_xpath('cameraPosition')&.content,
+          layout: event.at_xpath('layout')&.content,
+          presentationIsOpen: event.at_xpath('presentationIsOpen')&.content == "true",
+          isResizing: event.at_xpath('isResizing')&.content == "true"
+        }
+      end
     end
   end
 end

record-and-playback/presentation/scripts/publish/presentation.rb

@@ -1316,18 +1316,27 @@ def copy_media_files_helper(media, media_files, package_dir)
   end
 end
 
-def process_swap_events(events)
-  BigBlueButton.logger.info("Processing screenshare as content events")
+def process_layout_events(events)
+  BigBlueButton.logger.info("Processing screenshare as content and layout events")
   swap_events = BigBlueButton::Events.get_screenshare_as_content_events(events, @meeting_start.to_i, @meeting_end.to_i)
+  layout_events = BigBlueButton::Events.get_layout_broadcasted_events(events, @meeting_start.to_i, @meeting_end.to_i)
   @layout_swap_xml = Builder::XmlMarkup.new(indent: 2)
   @layout_swap_xml.instruct!
 
   @layout_swap_xml.recording('id' => 'layout_swap_events') do
-    swap_events.each do |event|
-      @layout_swap_xml.event(
-        timestamp: (event[:timestamp].to_f / 1000.0).round(1),
-        show_screenshare: event[:screenshareAsContent],
-      )
+    # Merge and sort events chronologically
+    all_events = (swap_events + layout_events).sort_by { |e| e[:timestamp] }
+
+    all_events.each do |event|
+      attributes = { timestamp: (event[:timestamp].to_f / 1000.0).round(1) }
+
+      if event.key?(:screenshareAsContent)
+        attributes[:show_screenshare] = event[:screenshareAsContent]
+      elsif event.key?(:presentationIsOpen)
+        attributes[:show_presentation] = event[:presentationIsOpen]
+      end
+
+      @layout_swap_xml.event(attributes)
     end
   end
 end
@@ -1497,7 +1506,7 @@ def process_swap_events(events)
 
         process_deskshare_events(@doc)
 
-        process_swap_events(@doc)
+        process_layout_events(@doc)
 
         process_poll_events(@doc, package_dir)