raoul
/
openlp
forked from openlp/openlp
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

more fixes

This commit is contained in:
Tim Bentley 2018-10-21 16:35:59 +01:00
parent bc7b772ed2
commit c08347ca3e
6 changed files with 66 additions and 133 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
openlp/core/state.py
View File

@ -90,6 +90,7 @@ class State(LogMixin):
def update_pre_conditions(self, name, status):
"""
Updates the preconditions state of a module
:param name: Module name
:param status: Module new status
:return:
@ -99,14 +100,25 @@ class State(LogMixin):
def flush_preconditions(self):
"""
Now all modules are loaded lets update all the preconditions.
:return:
"""
for mods in self.modules:
for req in self.modules[mods].required_by:
self.modules[mods].pass_preconditions = self.modules[req].pass_preconditions
self.modules[req].pass_preconditions = self.modules[mods].pass_preconditions
def is_module_active(self, name):
return self.modules[name].status == PluginStatus.Active
def check_active_dependency(self, name):
pass
def check_preconditions(self, name):
"""
Checks is a modules preconditions have been met and that of a required by module
:param name: Module name
:return: True / False
"""
if self.modules[name].requires is None:
return self.modules[name].pass_preconditions
else:
mod = self.modules[name].requires
return self.modules[mod].pass_preconditions

16
openlp/core/ui/media/mediacontroller.py
View File

@ -394,7 +394,10 @@ class MediaController(RegistryBase, LogMixin, RegistryProperties):
controller.media_info.is_background = video_behind_text
# background will always loop video.
controller.media_info.can_loop_playback = video_behind_text
controller.media_info.file_info = QtCore.QFileInfo(service_item.get_frame_path())
if service_item.is_capable(ItemCapabilities.HasBackgroundAudio):
controller.media_info.file_info = service_item.background_audio
else:
controller.media_info.file_info = QtCore.QFileInfo(service_item.get_frame_path())
display = self._define_display(controller)
if controller.is_live:
# if this is an optical device use special handling
@ -458,7 +461,7 @@ class MediaController(RegistryBase, LogMixin, RegistryProperties):
return True
@staticmethod
def media_length(service_item):
def media_length(media_path):
"""
Uses Media Info to obtain the media length
@ -466,18 +469,17 @@ class MediaController(RegistryBase, LogMixin, RegistryProperties):
"""
media_info = MediaInfo()
media_info.volume = 0
media_info.file_info = QtCore.QFileInfo(service_item.get_frame_path())
filename = service_item.get_frame_path()
media_info.file_info = media_path
filename = media_path
if pymediainfo.MediaInfo.can_parse():
media_data = pymediainfo.MediaInfo.parse(filename)
else:
xml = check_output(['mediainfo', '-f', '--Output=XML', '--Inform=OLDXML', filename])
if not xml.startswith(b'<?xml'):
xml = check_output(['mediainfo', '-f', '--Output=XML', filename])
media_data = pymediainfo.MediaInfo(xml)
media_data = pymediainfo.MediaInfo(xml.decode("utf-8"))
# duration returns in milli seconds
service_item.set_media_length(media_data.tracks[0].duration)
return True
return media_data.tracks[0].duration
def media_setup_optical(self, filename, title, audio_track, subtitle_track, start, end, display, controller):
"""

3
openlp/plugins/media/lib/mediaitem.py
View File

@ -25,6 +25,7 @@ import os
from PyQt5 import QtCore, QtWidgets
from openlp.core.state import State
from openlp.core.common.applocation import AppLocation
from openlp.core.common.i18n import UiStrings, translate, get_natural_key
from openlp.core.common.mixins import RegistryProperties
@ -174,6 +175,8 @@ class MediaMediaItem(MediaManagerItem, RegistryProperties):
:param remote: Triggered from remote
:param context: Why is it being generated
"""
if State().check_active_dependency():
a=1
if item is None:
item = self.list_view.currentItem()
if item is None:

13
openlp/plugins/media/mediaplugin.py
View File

@ -74,19 +74,6 @@ class MediaPlugin(Plugin):
"""
super().initialise()
def check_pre_conditions(self):
"""
Check it we have a valid environment.
:return: true or false
"""
log.debug('check_installed Mediainfo')
# Try to find mediainfo in the path
exists = process_check_binary(Path('mediainfo'))
# If mediainfo is not in the path, try to find it in the application folder
if not exists:
exists = process_check_binary(AppLocation.get_directory(AppLocation.AppDir) / 'mediainfo')
return exists
def app_startup(self):
"""
Override app_startup() in order to do nothing

33
tests/functional/openlp_core/test_state.py
View File

@ -119,13 +119,32 @@ class TestState(TestCase, TestMixin):
State().add_service("test", 1, PluginStatus.Inactive)
State().add_service("test2", 1, PluginStatus.Inactive)
State().add_service("test1", 1, PluginStatus.Inactive, 'test')
State().update_pre_conditions('test1', False)
State().update_pre_conditions('test', False)
# THEN correct the state when I flush the preconditions
assert State().modules['test'].pass_preconditions == True
assert State().modules['test2'].pass_preconditions == True
assert State().modules['test1'].pass_preconditions == False
assert State().modules['test'].pass_preconditions is False
assert State().modules['test2'].pass_preconditions is True
assert State().modules['test1'].pass_preconditions is True
State().flush_preconditions()
assert State().modules['test'].pass_preconditions == False
assert State().modules['test2'].pass_preconditions == True
assert State().modules['test1'].pass_preconditions == False
assert State().modules['test'].pass_preconditions is False
assert State().modules['test2'].pass_preconditions is True
assert State().modules['test1'].pass_preconditions is False
# def test_check_preconditions(self):
# # GIVEN a new state
# State().load_settings()
#
# # WHEN I add a new services with dependancies and a failed pre condition
# State().add_service("test", 1, PluginStatus.Inactive)
# State().add_service("test2", 1, PluginStatus.Inactive)
# State().add_service("test1", 1, PluginStatus.Inactive, 'test')
# State().update_pre_conditions('test', False)
#
# # THEN correct the state when I flush the preconditions
# assert State().modules['test'].pass_preconditions is False
# assert State().modules['test2'].pass_preconditions is True
# assert State().modules['test1'].pass_preconditions is True
# State().flush_preconditions()
# assert State().modules['test'].pass_preconditions is False
# assert State().modules['test2'].pass_preconditions is True
# assert State().modules['test1'].pass_preconditions is False

116
tests/functional/openlp_core/ui/media/test_mediacontroller.py
View File

@ -49,19 +49,18 @@ class TestMediaController(TestCase, TestMixin):
"""
# GIVEN: A MediaController and an active player with audio and video extensions
media_controller = MediaController()
media_player = MediaPlayer(None)
media_player.is_active = True
media_player.audio_extensions_list = ['*.mp3', '*.wav', '*.wma', '*.ogg']
media_player.video_extensions_list = ['*.mp4', '*.mov', '*.avi', '*.ogm']
media_controller.register_players(media_player)
media_controller.media_players = MediaPlayer(None)
media_controller.media_players.is_active = True
media_controller.media_players.audio_extensions_list = ['*.mp3', '*.wav', '*.wma', '*.ogg']
media_controller.media_players.video_extensions_list = ['*.mp4', '*.mov', '*.avi', '*.ogm']
# WHEN: calling _generate_extensions_lists
media_controller._generate_extensions_lists()
# THEN: extensions list should have been copied from the player to the mediacontroller
assert media_player.video_extensions_list == media_controller.video_extensions_list, \
assert media_controller.video_extensions_list == media_controller.video_extensions_list, \
'Video extensions should be the same'
assert media_player.audio_extensions_list == media_controller.audio_extensions_list, \
assert media_controller.audio_extensions_list == media_controller.audio_extensions_list, \
'Audio extensions should be the same'
def test_resize(self):
@ -79,112 +78,23 @@ class TestMediaController(TestCase, TestMixin):
# THEN: The player's resize method should be called correctly
mocked_player.resize.assert_called_with(mocked_display)
def test_check_file_type_no_players(self):
def test_check_file_type(self):
"""
Test that we don't try to play media when no players available
"""
# GIVEN: A mocked UiStrings, get_used_players, controller, display and service_item
with patch('openlp.core.ui.media.mediacontroller.MediaController._get_used_players') as \
mocked_get_used_players,\
patch('openlp.core.ui.media.mediacontroller.UiStrings') as mocked_uistrings:
mocked_get_used_players.return_value = ([])
mocked_ret_uistrings = MagicMock()
mocked_ret_uistrings.Automatic = 1
mocked_uistrings.return_value = mocked_ret_uistrings
media_controller = MediaController()
mocked_controller = MagicMock()
mocked_display = MagicMock()
mocked_service_item = MagicMock()
mocked_service_item.processor = 1
# WHEN: calling _check_file_type when no players exists
ret = media_controller._check_file_type(mocked_controller, mocked_display, mocked_service_item)
# THEN: it should return False
assert ret is False, '_check_file_type should return False when no mediaplayers are available.'
@patch('openlp.core.ui.media.mediacontroller.MediaController._get_used_players')
@patch('openlp.core.ui.media.mediacontroller.UiStrings')
def test_check_file_type_no_processor(self, mocked_uistrings, mocked_get_used_players):
"""
Test that we don't try to play media when the processor for the service item is None
"""
# GIVEN: A mocked UiStrings, get_media_players, controller, display and service_item
mocked_get_used_players.return_value = ([], '')
mocked_ret_uistrings = MagicMock()
mocked_ret_uistrings.Automatic = 1
mocked_uistrings.return_value = mocked_ret_uistrings
media_controller = MediaController()
mocked_controller = MagicMock()
mocked_display = MagicMock()
mocked_service_item = MagicMock()
mocked_service_item.processor = None
# WHEN: calling _check_file_type when the processor for the service item is None
ret = media_controller._check_file_type(mocked_controller, mocked_display, mocked_service_item)
# THEN: it should return False
assert ret is False, '_check_file_type should return False when the processor for service_item is None.'
@patch('openlp.core.ui.media.mediacontroller.MediaController._get_used_players')
@patch('openlp.core.ui.media.mediacontroller.UiStrings')
def test_check_file_type_automatic_processor(self, mocked_uistrings, mocked_get_used_players):
"""
Test that we can play media when players are available and we have a automatic processor from the service item
"""
# GIVEN: A mocked UiStrings, get_media_players, controller, display and service_item
mocked_get_used_players.return_value = (['vlc', 'webkit'])
mocked_ret_uistrings = MagicMock()
mocked_ret_uistrings.Automatic = 1
mocked_uistrings.return_value = mocked_ret_uistrings
media_controller = MediaController()
mocked_vlc = MagicMock()
mocked_vlc.video_extensions_list = ['*.mp4']
media_controller.media_players = {'vlc': mocked_vlc, 'webkit': MagicMock()}
mocked_controller = MagicMock()
mocked_suffix = MagicMock()
mocked_suffix.return_value = 'mp4'
mocked_controller.media_info.file_info.suffix = mocked_suffix
mocked_display = MagicMock()
mocked_service_item = MagicMock()
mocked_service_item.processor = 1
media_controller.media_players = MagicMock()
# WHEN: calling _check_file_type when the processor for the service item is None
# WHEN: calling _check_file_type when no players exists
ret = media_controller._check_file_type(mocked_controller, mocked_display, mocked_service_item)
# THEN: it should return True
assert ret is True, '_check_file_type should return True when mediaplayers are available and ' \
'the service item has an automatic processor.'
@patch('openlp.core.ui.media.mediacontroller.MediaController._get_used_players')
@patch('openlp.core.ui.media.mediacontroller.UiStrings')
def test_check_file_type_processor_different_from_available(self, mocked_uistrings, mocked_get_used_players):
"""
Test that we can play media when players available are different from the processor from the service item
"""
# GIVEN: A mocked UiStrings, get_media_players, controller, display and service_item
mocked_get_used_players.return_value = (['system'])
mocked_ret_uistrings = MagicMock()
mocked_ret_uistrings.Automatic = 'automatic'
mocked_uistrings.return_value = mocked_ret_uistrings
media_controller = MediaController()
mocked_phonon = MagicMock()
mocked_phonon.video_extensions_list = ['*.mp4']
media_controller.media_players = {'system': mocked_phonon}
mocked_controller = MagicMock()
mocked_suffix = MagicMock()
mocked_suffix.return_value = 'mp4'
mocked_controller.media_info.file_info.suffix = mocked_suffix
mocked_display = MagicMock()
mocked_service_item = MagicMock()
mocked_service_item.processor = 'vlc'
# WHEN: calling _check_file_type when the processor for the service item is None
ret = media_controller._check_file_type(mocked_controller, mocked_display, mocked_service_item)
# THEN: it should return True
assert ret is True, '_check_file_type should return True when the players available are different' \
'from the processor from the service item.'
# THEN: it should return False
assert ret is False, '_check_file_type should return False when no mediaplayers are available.'
def test_media_play_msg(self):
"""
@ -265,13 +175,13 @@ class TestMediaController(TestCase, TestMixin):
"""
Test the Media Info basic functionality
"""
media_controller = MediaController()
for test_data in TEST_MEDIA:
# GIVEN: a media file
full_path = str(TEST_PATH / test_data[0])
media_controller = MediaController()
# WHEN the media data is retrieved
results = media_controller.media_length(full_path)
# THEN you can determine the run time
assert results.tracks[0].duration == test_data[1], 'The correct duration is returned for ' + test_data[0]
assert results == test_data[1], 'The correct duration is returned for ' + test_data[0]