def test_3_multi_browser_message(self):
"""
Send message containing one asset directed at 'center' viewport
assert for:
- one browser on 'center' viewport and check url + geometry (with viewport offset)
- empty browsers list on the other viewport
"""
self.bridge_center.translate_director(self.message_3)
self.bridge_right.translate_director(self.message_3)
self.assertEqual(1, len(self.mock_publisher_center.published_messages))
self.assertEqual(1, len(self.mock_publisher_right.published_messages))
center_browser_1 = AdhocBrowser(id='adhoc_browser_center_0',
scene_slug='test message',
version='stable',
kiosk=True,
geometry=WindowGeometry(x=10,
y=10,
width=600,
height=800),
url='http://www.lol.zomg')
center_browser_2 = AdhocBrowser(id='adhoc_browser_center_1',
scene_slug='test message',
version='stable',
kiosk=True,
geometry=WindowGeometry(x=400,
y=200,
width=300,
height=200),
url='http://www.lol2.zomg')
center_browser_3 = AdhocBrowser(id='adhoc_browser_center_2',
scene_slug='test message',
version='stable',
kiosk=True,
geometry=WindowGeometry(x=10,
y=10,
width=888,
height=11),
url='http://www.lol3.zomg')
right_browser_4 = AdhocBrowser(id='adhoc_browser_right_0',
scene_slug='test message',
version='stable',
kiosk=True,
geometry=WindowGeometry(x=100,
y=100,
width=100,
height=100),
url='http://www.lol4.zomg')
rospy.loginfo("published adhoc browser => %s" % self.mock_publisher_center.published_messages[0])
rospy.loginfo("asserted adhoc browser => %s" % AdhocBrowsers(browsers=[center_browser_1, center_browser_2, center_browser_3]))
self.assertEqual(zero_id(AdhocBrowsers(browsers=[center_browser_1, center_browser_2, center_browser_3], scene_slug='test message')),
zero_id(self.mock_publisher_center.published_messages[0]))
self.assertEqual(zero_id(AdhocBrowsers(browsers=[right_browser_4], scene_slug='test message')),
zero_id(self.mock_publisher_right.published_messages[0]))
self.assertEqual(AdhocBrowsers, type(self.mock_publisher_center.published_messages[0]))
self.assertEqual(AdhocBrowsers, type(self.mock_publisher_right.published_messages[0]))
def test_3_multi_mplayer_message(self):
"""
Send message containing one asset directed at 'center' viewport
assert for:
- one mplayer on 'center' viewport and check url + geometry (with viewport offset)
- empty mplayers list on the other viewport
"""
self.bridge_center.translate_director(self.message_3)
self.bridge_right.translate_director(self.message_3)
self.assertEqual(1, len(self.mock_publisher_center.published_messages))
self.assertEqual(1, len(self.mock_publisher_right.published_messages))
center_mplayer_1 = AdhocMedia(
id='adhoc_media_video_center_0',
geometry=WindowGeometry(x=10, y=10, width=600, height=800),
media_type='video',
url='http://lg-head/lg/assets/videos/bunny.mp4',
on_finish='nothing')
center_mplayer_2 = AdhocMedia(
id='adhoc_media_video_center_1',
geometry=WindowGeometry(x=400, y=200, width=300, height=200),
media_type='video',
url='http://lg-head/lg/assets/videos/bunny.mp4',
on_finish='nothing')
center_mplayer_3 = AdhocMedia(
id='adhoc_media_video_center_2',
geometry=WindowGeometry(x=10, y=10, width=888, height=11),
media_type='video',
url='http://lg-head/lg/assets/videos/bunny.mp4',
on_finish='nothing')
right_mplayer_4 = AdhocMedia(
id='adhoc_media_video_right_0',
geometry=WindowGeometry(x=100, y=100, width=100, height=100),
media_type='video',
url='http://lg-head/lg/assets/videos/bunny.mp4',
on_finish='nothing')
rospy.loginfo("published adhoc mplayer => %s" %
self.mock_publisher_center.published_messages[0])
rospy.loginfo("asserted adhoc mplayer => %s" % AdhocMedias(
medias=[center_mplayer_1, center_mplayer_2, center_mplayer_3]))
self.assertEqual(
AdhocMedias(
medias=[center_mplayer_1, center_mplayer_2, center_mplayer_3]),
self.mock_publisher_center.published_messages[0])
self.assertEqual(AdhocMedias(medias=[right_mplayer_4]),
self.mock_publisher_right.published_messages[0])
self.assertEqual(
AdhocMedias,
type(self.mock_publisher_center.published_messages[0]))
self.assertEqual(AdhocMedias,
type(self.mock_publisher_right.published_messages[0]))
def setUp(self):
"""
- instantiate ManagedAdhocBrowser
- run asserts on object's parameters
"""
self.width = 1000
self.height = 1001
self.x = 1002
self.y = 1003
self.slug = 'testing_slug'
self.url = 'http://justtesting.com'
self.geometry = WindowGeometry(width=self.width,
height=self.height,
x=self.x,
y=self.y)
self.mab = ManagedAdhocBrowser(geometry=self.geometry,
slug=self.slug,
url=self.url)
super(ManagedAdhocBrowser, self.mab).__init__(
geometry=self.geometry,
slug=self.slug,
url=self.url,
kiosk=True)
rospy.logdebug("This is mab: %s" % self.mab.__dict__)
def __init__(self, config_path, viewport):
self.config_path = config_path
self.viewport = viewport
self.selected = False
viewport_geometry = ManagedWindow.lookup_viewport_geometry(self.viewport)
cmd = ['/usr/bin/onboard', '-m']
onboard_width = viewport_geometry.width
onboard_height = viewport_geometry.height / 4
onboard_x = viewport_geometry.x
onboard_y = viewport_geometry.y + (viewport_geometry.height - onboard_height)
onboard_geometry = WindowGeometry(x=onboard_x,
y=onboard_y,
width=onboard_width,
height=onboard_height)
self.config = OnboardConfig(config_path=config_path).get_config()
window = ManagedWindow(w_class='Onboard',
geometry=onboard_geometry,
visible=False)
cmd.extend(map(str,
['-x',
onboard_x,
'-y', onboard_y,
'-s',
'{}x{}'.format(onboard_width, onboard_height)]))
self.app = ManagedApplication(cmd, window=window)
def _create_mplayer(self, mplayer_id, incoming_mplayer):
"""
Start a ManagedApplication instance according to the details in the
media argument and return process instance, FIFO file (full path) to
drive the mplayer application and resource URL.
"""
fifo_path = self._create_fifo(mplayer_id)
geometry = WindowGeometry(x=incoming_mplayer.geometry.x,
y=incoming_mplayer.geometry.y,
width=incoming_mplayer.geometry.width,
height=incoming_mplayer.geometry.height)
mplayer_window = ManagedWindow(geometry=geometry,
w_instance=str(mplayer_id),
w_class="MPlayer")
if incoming_mplayer.on_finish == "nothing" or incoming_mplayer.on_finish == "close":
respawn = False
else:
respawn = True
mplayer = ManagedMplayer(fifo_path=fifo_path,
url=incoming_mplayer.url,
slug=mplayer_id,
window=mplayer_window,
respawn=respawn)
mplayer.set_state(ApplicationState.VISIBLE)
rospy.logdebug(
"MPlayer Pool: started new mplayer instance %s on viewport %s with id %s"
% (self.viewport_name, incoming_mplayer, mplayer_id))
self.mplayers[mplayer_id] = mplayer
return True
def setUp(self):
"""
- instantiate ManagedMplayer
- run asserts on object's parameters
"""
self.width = 1000
self.height = 1001
self.x = 1002
self.y = 1003
self.slug = 'testing_slug'
self.url = 'http://lg-head/lg/assets/videos/bunny.mp4'
self.fifo_path = '/tmp/asd_lol'
self.cmd = '-idle -slave'
self.geometry = WindowGeometry(width=self.width,
height=self.height,
x=self.x,
y=self.y)
self.window = ManagedWindow(
geometry=self.geometry,
w_instance="Mplayer \\({}\\)".format(self.slug),
w_class="Mplayer \\({}\\)".format(self.slug))
self.mam = ManagedMplayer(window=self.window,
fifo_path=self.fifo_path,
slug=self.slug,
url=self.url)
super(ManagedMplayer, self.mam).__init__(cmd=self.cmd,
window=self.window)
rospy.logdebug("This is mam: %s" % self.mam.__dict__)
def _get_browser_window_geometry(self, adhoc_browser_msg):
"""
accepts AdhocBrowser message and returns WindowGeometry class instance
"""
return WindowGeometry(x=adhoc_browser_msg.geometry.x,
y=adhoc_browser_msg.geometry.y,
width=adhoc_browser_msg.geometry.width,
height=adhoc_browser_msg.geometry.height)
def combine_viewport_geometries(viewport_names):
geometries = [ManagedWindow.lookup_viewport_geometry(v) for v in viewport_names]
combined = WindowGeometry(
x=geometries[0].x,
y=geometries[0].y,
width=geometries[0].width,
height=geometries[0].height
)
for geometry in geometries:
combined.x = min(combined.x, geometry.x)
combined.y = min(combined.y, geometry.y)
combined.width = max(combined.width, geometry.x - combined.x + geometry.width)
combined.height = max(combined.height, geometry.y - combined.y + geometry.height)
return combined
def _get_viewport_offset(self):
"""
Adhoc browser needs geometry that's honoring viewport offsets
This method will add viewport offset
"""
viewport_geometry = ManagedWindow.get_viewport_geometry()
if not viewport_geometry:
viewport_geometry = WindowGeometry()
return {'x': viewport_geometry.x, 'y': viewport_geometry.y}
def _get_viewport_offset(self):
"""
Director messages contain offset and size local to the screen that media
should be displayed on.
Screens have their own offsets that should be honored during ManagedWindow creation.
This method will return `real` offset.
"""
viewport_geometry = ManagedWindow.get_viewport_geometry()
if not viewport_geometry:
viewport_geometry = WindowGeometry()
return {'x': viewport_geometry.x, 'y': viewport_geometry.y}
def _instantiate_player(self, window, instance_name):
geometry = WindowGeometry(width=window['width'],
height=window['height'],
x=self.geometry.x + window['x_coord'],
y=self.geometry.y + window['y_coord'])
conf = window.get('activity_config', {})
source_viewport = conf.get('viewport', '')
source_viewport = source_viewport.replace('viewport://', '')
rospy.loginfo("Using geometry for playback: %s" % geometry)
player = MirrorPlayback(instance_name=instance_name,
janus_url=self.janus_url,
source_viewport=source_viewport,
geometry=geometry)
return player
def parse_geometry(geometry):
"""
Parses Xorg window geometry in the form WxH[+-]X[+-]Y
Raises ValueError if the geometry string is invalid.
"""
m = re.match(r'^(\d+)x(\d+)([+-]\d+)([+-]\d+)$', geometry)
if m is None:
raise ValueError('Invalid window geometry: {}'.format(geometry))
dims = map(int, m.groups())
return WindowGeometry(width=dims[0],
height=dims[1],
x=dims[2],
y=dims[3])
def _start_capture(self, window):
# Find dimensions that fit in the destination window,
# while preserving the source aspect ratio.
target_geometry = WindowGeometry(x=window['x_coord'],
y=window['y_coord'],
width=window['width'],
height=window['height'])
target_width, target_height = aspect_scale_source(
target_geometry, self.geometry)
# If we were already capturing for this target, NOP.
if (self._gst is not None and self._previous_width == target_width
and self._previous_height == target_height):
return
# Otherwise, continue exclusively.
self._end_capture()
self._previous_width = target_width
self._previous_height = target_height
pipeline = ' '.join(
map(
lambda arg: arg.format(
startx=self.geometry.x,
starty=self.geometry.y,
# Subtract 1 from width/height to workaround gstreamer wierdness.
endx=self.geometry.x + self.geometry.width - 1,
endy=self.geometry.y + self.geometry.height - 1,
show_pointer=str(self.show_pointer).lower(),
framerate=self.framerate,
quality=self.quality,
target_width=target_width,
target_height=target_height,
display=self.display),
CAPTURE_PIPELINE))
self._gst = GstPublisher(pipeline, self.image_pub)
self._gst.start()
def combine_viewport_geometries(viewport_names):
geometries = [
ManagedWindow.lookup_viewport_geometry(v) for v in viewport_names
]
combined = WindowGeometry(x=geometries[0].x,
y=geometries[0].y,
width=geometries[0].width,
height=geometries[0].height)
for geometry in geometries:
combined.x = min(combined.x, geometry.x)
combined.y = min(combined.y, geometry.y)
combined.width = max(combined.width,
geometry.x - combined.x + geometry.width)
combined.height = max(combined.height,
geometry.y - combined.y + geometry.height)
return combined
def test_equality(self):
sg = WindowGeometry(width=1920, height=1080, x=0, y=0)
dg = WindowGeometry(width=1920, height=1080, x=0, y=0)
self.check_dimensions(sg, dg, 1920, 1080)
def test_portrait_to_landscape(self):
sg = WindowGeometry(width=1080, height=1920, x=0, y=0)
dg = WindowGeometry(width=1920, height=1080, x=0, y=0)
expected_width = int(round(1080 / (1920. / 1080.)))
self.check_dimensions(sg, dg, expected_width, 1080)
def test_scale_up_landscape_to_portrait(self):
sg = WindowGeometry(width=1920, height=1080, x=0, y=0)
dg = WindowGeometry(width=2160, height=3840, x=0, y=0)
# Should never scale larger than source geometry.
self.check_dimensions(sg, dg, 1920, 1080)
def test_scale_down_landscape_to_portrait(self):
sg = WindowGeometry(width=3840, height=2160, x=0, y=0)
dg = WindowGeometry(width=1080, height=1920, x=0, y=0)
expected_height = int(round(1080 / (3840. / 2160.)))
self.check_dimensions(sg, dg, 1080, expected_height)
def test_scale_down(self):
sg = WindowGeometry(width=3840, height=2160, x=0, y=0)
dg = WindowGeometry(width=1920, height=1080, x=0, y=0)
self.check_dimensions(sg, dg, 1920, 1080)