130 lines
5.2 KiB
Python
130 lines
5.2 KiB
Python
from kivy.app import App
|
|
from kivy.uix.screenmanager import ScreenManager, Screen
|
|
from kivy.clock import Clock
|
|
from kivy.core.window import Window
|
|
from kivy.uix.video import Video
|
|
from kivy.uix.image import Image
|
|
from kivy.uix.boxlayout import BoxLayout
|
|
import requests
|
|
import os
|
|
import json
|
|
from kivy.config import Config
|
|
from kivy.logger import Logger
|
|
Config.set('kivy', 'keyboard_mode', 'systemanddock')
|
|
|
|
class MediaPlayer(Screen):
|
|
def __init__(self, **kwargs):
|
|
super(MediaPlayer, self).__init__(**kwargs)
|
|
self.playlist = []
|
|
self.current_index = 0
|
|
self.video_player = Video()
|
|
self.image_display = Image()
|
|
self.layout = BoxLayout(orientation='vertical')
|
|
self.layout.add_widget(self.video_player)
|
|
self.layout.add_widget(self.image_display)
|
|
self.add_widget(self.layout)
|
|
Clock.schedule_interval(self.check_playlist_updates, 300) # Check for updates every 5 minutes
|
|
Window.bind(on_key_down=self.on_key_down)
|
|
|
|
def on_key_down(self, window, key, *args):
|
|
if key == 102: # 'f' key
|
|
Window.fullscreen = not Window.fullscreen
|
|
|
|
def on_enter(self):
|
|
self.load_playlist()
|
|
self.download_media_files()
|
|
self.play_media()
|
|
|
|
def load_playlist(self):
|
|
# Load playlist from the server or local storage
|
|
try:
|
|
Logger.debug("Attempting to load playlist from server...")
|
|
server_ip = 'http://192.168.0.115:5000'
|
|
hostname = 'player1.local'
|
|
quickconnect_code = 'Initial01!'
|
|
url = f'{server_ip}/api/playlists'
|
|
params = {
|
|
'hostname': "TvHolBa1",
|
|
'quickconnect_code': quickconnect_code
|
|
}
|
|
response = requests.get(url, params=params)
|
|
|
|
# Print the raw response content and status code for debugging
|
|
Logger.debug(f'Status Code: {response.status_code}')
|
|
Logger.debug(f'Response Content: {response.text}')
|
|
|
|
# Check if the request was successful
|
|
if response.status_code == 200:
|
|
try:
|
|
# Parse the JSON response
|
|
self.playlist = response.json().get('playlist', [])
|
|
Logger.debug(f'Playlist: {self.playlist}')
|
|
except json.JSONDecodeError as e:
|
|
Logger.error(f'Failed to parse JSON response: {e}')
|
|
else:
|
|
Logger.error(f'Failed to retrieve playlist: {response.text}')
|
|
except requests.exceptions.RequestException as e:
|
|
Logger.error(f"Failed to load playlist: {e}")
|
|
|
|
def download_media_files(self):
|
|
base_dir = os.path.join(os.path.dirname(__file__), 'static', 'resurse') # Update this to the correct path
|
|
if not os.path.exists(base_dir):
|
|
os.makedirs(base_dir)
|
|
|
|
for media in self.playlist:
|
|
file_name = media.get('file_name', '')
|
|
file_url = f"http://192.168.0.115:5000/media/{file_name}" # Update this to the correct URL
|
|
file_path = os.path.join(base_dir, file_name)
|
|
|
|
try:
|
|
response = requests.get(file_url)
|
|
if response.status_code == 200:
|
|
with open(file_path, 'wb') as file:
|
|
file.write(response.content)
|
|
Logger.debug(f"Downloaded {file_name} to {file_path}")
|
|
else:
|
|
Logger.error(f"Failed to download {file_name}: {response.status_code}")
|
|
except requests.exceptions.RequestException as e:
|
|
Logger.error(f"Failed to download {file_name}: {e}")
|
|
|
|
def play_media(self):
|
|
if self.playlist:
|
|
media = self.playlist[self.current_index]
|
|
file_name = media.get('file_name', '')
|
|
file_extension = os.path.splitext(file_name)[1].lower()
|
|
duration = media.get('duration', 10) # Default duration is 10 seconds
|
|
|
|
# Define the base directory for media files
|
|
base_dir = os.path.join(os.path.dirname(__file__), 'static', 'resurse') # Update this to the correct path
|
|
file_path = os.path.join(base_dir, file_name)
|
|
|
|
if file_extension in ['.mp4', '.avi', '.mov']:
|
|
self.video_player.source = file_path
|
|
self.video_player.play()
|
|
self.image_display.source = ''
|
|
elif file_extension in ['.jpg', '.jpeg', '.png', '.gif']:
|
|
self.image_display.source = file_path
|
|
self.video_player.source = ''
|
|
self.image_display.reload()
|
|
Clock.schedule_once(self.next_media, duration)
|
|
else:
|
|
Logger.error(f"Unsupported media type for file: {file_name}")
|
|
|
|
def next_media(self, dt):
|
|
self.current_index = (self.current_index + 1) % len(self.playlist)
|
|
self.play_media()
|
|
|
|
def check_playlist_updates(self, dt):
|
|
self.load_playlist()
|
|
self.download_media_files()
|
|
self.play_media()
|
|
|
|
class MediaPlayerApp(App):
|
|
def build(self):
|
|
Window.fullscreen = True
|
|
sm = ScreenManager()
|
|
sm.add_widget(MediaPlayer(name='media_player'))
|
|
return sm
|
|
|
|
if __name__ == '__main__':
|
|
MediaPlayerApp().run() |