def main():
if len(sys.argv) > 1:
config_file_name = sys.argv[1]
else:
config_file_name = 'config.json'
with open(config_file_name, 'r') as f:
config = json.load(f)
pygame.init()
random.seed()
# Need to hide mouse pointer here since the MediaPlayer class
# might be used to render on a surface instead of a display
pygame.mouse.set_visible(False)
screen = Screen(width=config['display']['width'],
height=config['display']['height'],
bg_color=pygame.Color('black'),
fullscreen=config['display']['fullscreen'])
screen_surface = screen.surface
play_again = True
while play_again:
player = MediaPlayer(surface=screen_surface,
config=config,
surface_is_display=True)
play_again = player.run()
pygame.quit()
def test_empty_playlist_if_cannot_reach_xos_and_no_cache():
"""
Test that if XOS is unreachable and there is no cache, the playlist is empty.
"""
media_player = MediaPlayer()
media_player.download_playlist_from_xos()
assert not media_player.playlist
def test_get_current_time_interpolates():
"""
Check that get_current_time interpolates the time from vlc.
"""
player = MediaPlayer()
mock_player = MagicMock()
mock_player.get_time = MagicMock(return_value=250)
player.vlc['player'] = mock_player
assert player.get_current_time() == 250
assert player.get_current_time() == 260
assert player.get_current_time() == 270
def test_client_drifts_from_server():
"""
Check that if the time drifts, the client calls set_time on its player.
"""
player = MediaPlayer()
player.client.receive = MagicMock(return_value=50)
player.get_current_time = MagicMock(return_value=100)
assert_called_in_infinite_loop(
'vlc.MediaPlayer.set_time',
player.sync_to_server
)
def test_still_plays_if_cannot_reach_xos():
"""
Test that a playlist is not empty even if XOS is unreachable.
"""
copyfile('tests/data/test_cached_playlist.json', 'test_cached_playlist.json')
media_player = MediaPlayer()
media_player.download_playlist_from_xos()
assert len(media_player.playlist) == 9
os.remove('test_cached_playlist.json')
def test_client_drifts_from_server_sets_playlist_position():
"""
Check that if the time drifts on a server playing a playlist,
the client calls play_item_at_index on its player.
"""
player = MediaPlayer()
player.client.receive = MagicMock(return_value=[2, 50])
player.get_current_time = MagicMock(return_value=100)
player.get_current_playlist_position = MagicMock(return_value=1)
player.vlc['player'].get_length = MagicMock(return_value=3000)
assert_called_in_infinite_loop('vlc.MediaListPlayer.play_item_at_index',
player.sync_to_server)
def test_download_playlist_from_xos():
"""
Test download_playlist_from_xos() returns a valid playlist.
"""
media_player = MediaPlayer()
media_player.download_playlist_from_xos()
playlist = media_player.playlist
assert len(playlist) == 3
assert playlist[0]['resource'] == '/data/resources/sample.mp4'
assert playlist[0]['subtitles'] == '/data/resources/sample.srt'
def test_server_sends_time_to_client():
"""
Check that the server sends data to the clients.
"""
player = MediaPlayer()
player.get_current_playlist_position = MagicMock(return_value=1)
assert_called_in_infinite_loop('media_player.MediaPlayer.get_current_time',
player.sync_to_server)
with pytest.raises(AssertionError):
player.get_current_playlist_position = MagicMock(return_value=None)
assert_called_in_infinite_loop(
'media_player.MediaPlayer.get_current_time', player.sync_to_server)
def test_server_set_up():
"""
Check that the server is correctly set up.
"""
player = MediaPlayer()
assert player.server is not None
assert getattr(player, 'client', None) is None
def test_client_receives_time_from_server():
"""
Check that the client receives data from the server.
"""
player = MediaPlayer()
assert_called_in_infinite_loop('media_player.MediaPlayer.get_current_time',
player.sync_to_server)
def test_run_timer():
"""
Check that the get_current_time method gets called when running the timer.
"""
player = MediaPlayer()
assert_called_in_infinite_loop('media_player.MediaPlayer.get_current_time',
player.run_timer)
def main():
with open('media-config.json', 'r') as f:
media_config = json.load(f)
with open('activity-config.json', 'r') as f:
activity_config = json.load(f)
# Small buffer size to prevent delays when playing sounds
pygame.mixer.init(buffer=512)
pygame.init()
random.seed()
# Need to hide mouse pointer here since the other classes
# might be used to render on a surface instead of a display
pygame.mouse.set_visible(False)
screen = Screen(
width=activity_config['display']['width'],
height=activity_config['display']['height'],
bg_color=pygame.Color(activity_config['board']['bg_color']),
fullscreen=activity_config['display']['fullscreen'])
screen_surface = screen.surface
play_again = True
while True:
while play_again:
player = MediaPlayer(
surface=screen_surface,
config=media_config,
surface_is_display=True)
play_again = player.run()
play_again = True
while play_again:
board = ActivityBoard(
surface=screen_surface,
config=activity_config,
start_hidden=True,
surface_is_display=True)
play_again = board.run()
play_again = True
def _CreateMediaPlayer(self, video_panel_parent, control_panel_parent,
video_panel_click_callback):
'''
Override if a simple MediaPlayer is not enough
'''
return MediaPlayer(playerLock=self._playerLock,
video_parent_panel=video_panel_parent,
videoPanelClickCallback=video_panel_click_callback)
def test_server_sends_time_to_client():
"""
Check that the server sends data to the clients.
"""
player = MediaPlayer()
assert_called_in_infinite_loop(
'media_player.MediaPlayer.get_current_time',
player.sync_to_server
)
def test_client_playlist_position_set_without_drift():
"""
Check that a client's playlist position is set even if
the client hasn't drifted from the server.
"""
player = MediaPlayer()
player.client.receive = MagicMock(return_value=[2, 95])
player.get_current_time = MagicMock(return_value=100)
player.get_current_playlist_position = MagicMock(return_value=1)
player.vlc['player'].get_length = MagicMock(return_value=3000)
assert_called_in_infinite_loop('vlc.MediaListPlayer.play_item_at_index',
player.sync_to_server)
with pytest.raises(AssertionError):
# Assert playlist sync isn't called
player.get_current_playlist_position = MagicMock(return_value=2)
assert_called_in_infinite_loop(
'vlc.MediaListPlayer.play_item_at_index', player.sync_to_server)
def test_media_player():
"""
Test the Media Player class initialises.
"""
media_player = MediaPlayer()
assert media_player.playlist == []
assert len(media_player.vlc) == 4
assert all([vlc_var is not None for vlc_var in media_player.vlc.values()])
def test_delete_unneeded_resources():
"""
Test delete_unneeded_resources() deletes the expected files.
"""
media_player = MediaPlayer()
playlist = json.loads(file_to_string_strip_new_lines(
'data/playlist.json'))['playlist_labels']
files_deleted = media_player.delete_unneeded_resources(playlist)
assert len(files_deleted) == 0
playlist_2 = json.loads(
file_to_string_strip_new_lines(
'data/playlist-2.json'))['playlist_labels']
files_deleted_2 = media_player.delete_unneeded_resources(playlist_2)
assert len(files_deleted_2) == 2
assert 'sample.mp4' in files_deleted_2
assert 'sample.srt' in files_deleted_2
def test_client_drifts_from_server():
"""
Check that if the time drifts, the client calls set_time on its player.
"""
player = MediaPlayer()
player.client.receive = MagicMock(return_value=[1, 50])
player.get_current_time = MagicMock(return_value=100)
player.get_current_playlist_position = MagicMock(return_value=1)
player.vlc['player'].get_length = MagicMock(return_value=3000)
assert_called_in_infinite_loop('vlc.MediaPlayer.set_time',
player.sync_to_server)
with pytest.raises(AssertionError):
# Assert playlist sync isn't called
assert_called_in_infinite_loop(
'vlc.MediaListPlayer.play_item_at_index', player.sync_to_server)
# Assert sync isn't called within 2 seconds of the end of the current video
with pytest.raises(AssertionError):
player.client.receive = MagicMock(return_value=[1, 2500])
player.get_current_time = MagicMock(return_value=2000)
assert_called_in_infinite_loop('vlc.MediaPlayer.set_time',
player.sync_to_server)
def test_cache_playlist():
"""
Test that a downloaded playlist is cached.
"""
media_player = MediaPlayer()
media_player.download_playlist_from_xos()
playlist = media_player.playlist
with open('test_cached_playlist.json', encoding='utf-8') as json_file:
json_data = json.load(json_file)
playlist_labels = json_data['playlist_labels']
expected_resource = os.path.basename(playlist_labels[0]['resource'])
resource = os.path.basename(playlist[0]['resource'])
assert resource == expected_resource
subtitles = os.path.basename(playlist[0]['subtitles'])
expected_subtitles = os.path.basename(playlist_labels[0]['subtitles'])
assert subtitles == expected_subtitles
os.remove('test_cached_playlist.json')
def test_sync_to_server():
"""
Test that sync_to_server successfully resyncs for exceptions.
"""
player = MediaPlayer()
player.client.receive = MagicMock(return_value=None)
player.client.sync_attempts = 1
assert_called_in_infinite_loop(
'media_player.MediaPlayer.sync_check',
player.sync_to_server,
)
player.client.receive = MagicMock(return_value=[0, 0])
player.client.sync_attempts = 1
assert_called_in_infinite_loop(
'media_player.MediaPlayer.sync_check',
player.sync_to_server,
)
def test_sync_check():
"""
Test that setup_sync is called as expected in sync_check.
"""
player = MediaPlayer()
with patch.object(MediaPlayer, 'setup_sync',
wraps=player.setup_sync) as mock_setup_sync:
player.client.sync_attempts = 1
player.sync_check()
assert mock_setup_sync.call_count == 0
player.client.sync_attempts = 4
player.sync_check()
assert mock_setup_sync.call_count == 1
def test_get_media_player_status():
"""
Test get_media_player_status correctly outputs playback data.
"""
media_player = MediaPlayer()
media_player.playlist = [
{
'label': {
'id': 123
}
},
{
'label': {
'id': 456
}
},
{
'label': None
},
]
mock_vlc_player = MagicMock()
mock_vlc_player.get_media = MagicMock(return_value=MagicMock())
media_player.vlc['player'] = mock_vlc_player
mock_vlc_playlist = MagicMock()
mock_vlc_playlist.index_of_item = MagicMock(return_value=1)
media_player.vlc['playlist'] = mock_vlc_playlist
status = media_player.get_media_player_status()
mock_vlc_playlist.index_of_item = MagicMock(return_value=2)
media_player.vlc['playlist'] = mock_vlc_playlist
status_two = media_player.get_media_player_status()
assert 'datetime' in status.keys()
assert status['playlist_position'] == 1
assert status['label_id'] == 456
assert status_two['label_id'] is None
def main():
soma = SomaFM()
media_player = MediaPlayer()
screen = Screen()
# command handler
# execute commands after finger has moved off of the button (the release event)
def handler(channel, event):
# print("Got {} on channel {}".format(event, channel))
if event == "release":
buttonMappings[channel].execute()
# assign the command handler to the buttons
for x in range(6):
touch.on(x, handler)
# my commands
up = SomaCommand(media_player=media_player,
station=soma.stations['space_station'],
screen=screen)
down = SomaCommand(media_player=media_player,
station=soma.stations['drone_zone'],
screen=screen)
left = SomaCommand(media_player=media_player,
station=soma.stations['groove_salad'],
screen=screen)
minus = SomaCommand(media_player=media_player,
station=soma.stations['lush'],
screen=screen)
home = PausePlayCommand(media_player=media_player,
station=soma.stations['lush'],
screen=screen)
plus = ShutdownCommand(media_player=media_player,
station=soma.stations['lush'],
screen=screen)
# map channels (button index) to commands
buttonMappings = {0: up, 1: down, 2: left, 3: minus, 4: home, 5: plus}
signal.pause() # https://docs.python.org/2/library/signal.html
def start():
state.init()
storage = TagStorage(get_store_path())
state.set_storage(storage)
def nfcLoaded():
nfc_reader.onTagRead += on_tag_read
nfc_reader.onLoad += nfcLoaded
nfc_reader.start_nfc_thread()
web_interface.init()
player = MediaPlayer()
state.set_player(player)
# TODO: Startup Sound
#player.play_ding()
# Blocks, keep last.
web_interface.run_wait()
# the Free Software Foundation, either version 3 of the License, or
# any later version.
#
# 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from media_player import MediaPlayer
import gtk
import dbus
import dbus.service
import dbus.mainloop.glib
from media_service import SomeObject
############################################
# DPlayer version v 3.0 #
############################################
gtk.gdk.threads_init()
app = MediaPlayer()
dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
session_bus = dbus.SessionBus()
name = dbus.service.BusName("org.mpris.MediaPlayer2.SampleService" + app.dbus_id, session_bus)
app_ser = SomeObject(session_bus, "/org/mpris/MediaPlayer2")
app_ser.set_dmp(app)
gtk.main()
def _CreateMediaPlayer(self, video_panel_parent, control_panel_parent,
video_panel_click_callback):
return MediaPlayer(video_panel_parent, self._playerLock,
video_panel_click_callback)
