def __init__(self):
self.state_data = StateData()
self.monitoring = sys.platform == "linux" or sys.platform == "linux2"
self.state_data.name = Settings.get_string("name")
self.watch_thread = CustomThread(self.update_state, "State observer")
self.watch_thread.start()
self.memory_thread = CustomThread(self.check_memory, "Memory observer")
self.memory_thread.start()
def observe_player(self):
while True:
state = self.get_state().value
if state in [5, 6, 7]:
state = 0
new_state = PlayerState(state)
if new_state == PlayerState.Nothing and self.player_state.state != PlayerState.Nothing:
self.stop_player_thread = CustomThread(self.stop,
"Stopping player")
self.stop_player_thread.start()
self.player_state.start_update()
self.player_state.state = new_state
self.player_state.playing_for = self.get_position()
self.player_state.length = self.get_length()
self.player_state.audio_tracks = self.get_audio_tracks()
self.player_state.audio_track = self.get_audio_track()
self.player_state.sub_delay = self.get_subtitle_delay()
self.player_state.sub_track = self.get_selected_sub()
self.player_state.sub_tracks = self.get_subtitle_tracks()
self.player_state.volume = self.get_volume()
self.player_state.stop_update()
time.sleep(0.5)
def __init__(self):
self.running = False
self.current_rules = []
self.check_thread = CustomThread(self.check_rules, "Rule checker")
self.load_rules()
enabled = Database().get_stat("rules_enabled")
self.enabled = bool(enabled)
def player_state_change(self, old_state, new_state):
if old_state.state != new_state.state:
Logger().write(
LogVerbosity.Info, "Player state changed from " +
str(old_state.state) + " to " + str(new_state.state))
if new_state.state == PlayerState.Playing:
self.play_position = new_state.playing_for
self.play_length = new_state.length
if old_state.state != PlayerState.Paused and old_state.state != new_state.state and new_state.state == PlayerState.Playing:
self.update_subtitles(new_state)
self.next_epi_thread = CustomThread(
lambda: self.next_episode_manager.check_next_episode(
self.media_data, self.torrent), "Check next episode", [])
self.next_epi_thread.start()
if old_state.state != new_state.state and new_state.state == PlayerState.Nothing:
self.history_id = 0
self.media_data.reset()
self.stop_torrent()
if self.play_length != 0 and self.play_position / self.play_length > 0.9:
self.next_episode_manager.notify_next_episode(
self.play_next_episode)
else:
self.next_episode_manager.reset()
self.play_position = 0
self.play_length = 0
self.update_tracking(new_state)
def __init__(self):
self.media_data = MediaData()
self.torrent_data = TorrentData()
self.torrent = None
self.subtitle_provider = SubtitleProvider()
self.next_episode_manager = NextEpisodeManager()
self.play_position = 0
self.play_length = 0
self.history_id = 0
self.last_tracking_update = 0
self.dht_enabled = Settings.get_bool("dht")
if self.dht_enabled:
self.dht = DHTEngine()
self.dht.start()
EventManager.register_event(EventType.AbortingTorrent,
self.aborting_torrent)
EventManager.register_event(EventType.TorrentMediaSelectionRequired,
self.media_selection_required)
EventManager.register_event(EventType.TorrentMediaFileSet,
lambda x: self._start_playing_torrent())
EventManager.register_event(EventType.TorrentStopped,
lambda: self.on_torrent_stopped())
VLCPlayer().player_state.register_callback(self.player_state_change)
self.torrent_observer = CustomThread(self.observe_torrent,
"Torrent observer")
self.torrent_observer.start()
self.next_epi_thread = None
def start(self):
APIController.slaves = SlaveCollection()
log_verbosity = Settings.get_int("log_level")
if log_verbosity > 0:
flask_logger = logging.getLogger('werkzeug')
flask_logger.setLevel(logging.INFO)
if Settings.get_bool("slave"):
thread = CustomThread(self.internal_start_slave, "API controller",
[])
thread.start()
else:
thread = CustomThread(self.internal_start_master, "API controller",
[])
thread.start()
def stop_async(self, reason):
if self.state != PeerState.Started and self.state != PeerState.Starting:
return
self.stop_reason = reason
self.state = PeerState.Stopping
self.peer_stop_task = CustomThread(self.stop,
"Peer stopper " + str(self.id), [])
self.peer_stop_task.start()
def start(self):
if not self.pi:
return
self.cec_process = subprocess.Popen(['cec-client'],
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
t = CustomThread(self.__read_cec, "Cec reader", [])
t.start()
def search_subtitles(self, name, size, length, first_64k, last_64k):
Logger().write(
LogVerbosity.Info, "Going to search subs: name: " + name +
", size: " + str(size) + ", length: " + str(length))
self.sub_files = []
for source in self.subtitle_sources:
thread = CustomThread(
self.search_subtitles_thread, "Search subtitles",
[source, size, length, name, first_64k, last_64k])
thread.start()
def state(self, value):
if self._state != value:
old = self._state
self._state = value
if self.torrent.peer_manager is not None:
self.torrent.peer_manager.update_peer(self, old, value)
if value == PeerState.Started:
self.peer_state_task = CustomThread(
self.check_peer_state, "Check peer state " + str(self.id))
self.peer_state_task.start()
def request_peers(self, torrent):
if not self.initialized:
for uri in torrent.announce_uris:
if len([x for x in self.trackers if x.host == uri]) == 0:
tracker = TrackerFactory.create_tracker(uri)
if tracker is not None:
self.trackers.append(tracker)
Logger().write(LogVerbosity.Debug, "Initialized " + str(len(self.trackers)) + " trackers")
self.initialized = True
for tracker in self.trackers:
thread = CustomThread(self.tracker_announce, "Tracker announce", [tracker, torrent])
thread.start()
def start(self):
Logger().write(LogVerbosity.All, str(self.id) + ' Starting peer')
self.state = PeerState.Starting
self.connection_manager = PeerConnectionManager(self, self.uri)
self.download_manager = PeerDownloadManager(self)
self.metadata_manager = PeerMetaDataManager(self)
self.extension_manager = PeerExtensionManager(self)
self.counter = AverageCounter(self, 3)
self.peer_start_task = CustomThread(self.connection_manager.start,
"Start peer " + str(self.id))
self.peer_start_task.start()
Logger().write(LogVerbosity.Debug, str(self.id) + ' Peer started')
def __init__(self, port, on_node_seen, on_node_timeout, on_query):
self.port = port
self.socket = socket(AF_INET, SOCK_DGRAM)
self.socket.settimeout(0.1)
self.message_thread = CustomThread(self.message_thread_action,
"DHT message", [])
self.running = False
self.node_seen_handler = on_node_seen
self.node_timeout_handler = on_node_timeout
self.query_handler = on_query
self.last_send = 0
self.received_messages = []
self.to_send_messages = []
self.awaiting_messages = []
def __init__(self, name, update_interval):
super().__init__(None, name)
self.__name = name
self.__update_interval = update_interval
self.__callbacks = []
self.__changed = True
self.__last_update = 0
self.__start_state = None
self.__last_update_state = None
self.__wait_event = Event()
self.__running = False
self.__update_thread = CustomThread(self.__check_update,
name + " observer")
def __init__(self):
self.check_thread = CustomThread(self.check_presence,
"Presence checker")
self.running = False
self.check_interval = 5
self.device_gone_interval = 240
self.on_coming_home = None
self.on_leaving_home = None
self.anyone_home = True
self.pi = sys.platform == "linux" or sys.platform == "linux2"
self.device_states = [
DeviceState("Mobiel Jan", "192.168.2.51",
self.device_gone_interval),
DeviceState("Mobiel Melissa", "192.168.2.50",
self.device_gone_interval),
]
def start(self):
Logger().write(
LogVerbosity.Debug,
self.name + " starting listener on port " + str(self.port))
self.soc = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.soc.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.running = True
try:
self.soc.bind(("", self.port))
Logger().write(
LogVerbosity.Info, "StreamServer " + self.name +
" listening on port " + str(self.port))
except (socket.error, OSError) as e:
Logger().write(
LogVerbosity.Info,
"Couldn't start StreamServer " + self.name + ": " + str(e))
return
self.soc.listen(10)
try:
while True:
Logger().write(
LogVerbosity.Debug, "StreamServer " + self.name +
" listening for incoming connection")
conn, addr = self.soc.accept()
if not self.running:
break
ip, port = str(addr[0]), str(addr[1])
Logger().write(LogVerbosity.Debug,
'New connection from ' + ip + ':' + port)
thread = CustomThread(self.client_thread, "Stream request",
[conn])
thread.start()
except Exception as e:
Logger().write_error(e, "Stream server")
Logger().write(LogVerbosity.Debug,
"StreamServer " + self.name + " closing")
self.soc.close()
def __init__(self):
self.__vlc_instance = None
self.player_state = PlayerData()
self.instantiate_vlc()
self.media = None
self.__player = self.__vlc_instance.media_player_new()
self.__list_player = self.__vlc_instance.media_list_player_new()
self.__list_player.set_media_player(self.__player)
self.__event_manager = self.__player.event_manager()
self.set_volume(75)
EventManager.register_event(EventType.SetSubtitleFiles,
self.set_subtitle_files)
EventManager.register_event(EventType.StopPlayer, self.stop)
self.player_observer = CustomThread(self.observe_player,
"Player observer")
self.player_observer.start()
self.stop_player_thread = None
def start(self):
self.connected_on = 0
Logger().write(LogVerbosity.All, str(self.peer.id) + ' connecting to ' + str(self.uri.netloc))
Stats().add('peers_connect_try', 1)
if not self.connection.connect():
Stats().add('peers_connect_failed', 1)
if self.peer is not None:
Logger().write(LogVerbosity.All, str(self.peer.id) + ' could not connect to ' + str(self.uri.netloc))
self.peer.stop_async("Can't connect")
return
if self.peer.state is not PeerState.Starting:
return
self.connected_on = current_time()
self.peer.add_connected_peer_stat(self.peer.source)
Stats().add('peers_connect_success', 1)
Logger().write(LogVerbosity.Debug, str(self.peer.id) + ' connected to ' + str(self.uri.netloc))
self.peer.state = PeerState.Started
self.in_thread = CustomThread(self.socket_reader, "Peer " + str(self.peer.id) + " input")
self.in_thread.start()
def on_command(topic, command, args):
Logger().write(LogVerbosity.Debug, "Master command " + topic + ": " + command)
method = None
if topic == "media":
from MediaPlayer.MediaManager import MediaManager
method = getattr(MediaManager(), command)
if topic == "updater":
from Updater import Updater
method = getattr(Updater(), command)
if topic == "system":
if command == "restart_device":
os.system('sudo reboot')
if command == "restart_application":
python = sys.executable
os.execl(python, python, *sys.argv)
if command == "close_application":
sys.exit()
if method is not None:
cb_thread = CustomThread(method, "Master command", args)
cb_thread.start()
def stop_torrent(self):
if self.torrent:
thread = CustomThread(self.torrent.stop, "Torrent stopper")
thread.start()
self.torrent = None
def start(self):
self.running = True
self.thread = CustomThread(self.runner, self.name)
self.thread.start()
def request_cb(self, topic, callback, timeout, room, *args):
request_message = self._send_request(topic, args, room)
thread = CustomThread(self.wait_for_request_response, "Request callback " + topic, [request_message, timeout, callback])
thread.start()
def __init__(self):
self.cache = StatList()
self.changed = False
self.work_thread = CustomThread(self.save_stats, "Stat saver", [])
def start(self):
Logger().write(LogVerbosity.Info, "Starting network manager")
self.thread = CustomThread(self.execute, "Network IO")
self.thread.start()
def __init__(self, torrent):
TorrentManager.__init__(self, torrent, "Peer processor")
self.running = False
self.process_thread = CustomThread(self.process, "Peer processor")
def stop(self):
Logger().write(LogVerbosity.All, "Player stop")
thread = CustomThread(lambda: self.__player.stop(),
"Stopping VLC player")
thread.start()
def throw_event(event_type, args):
thread = CustomThread(EventManager.execute_handlers,
"EventHandler " + str(event_type),
args=[event_type, args])
thread.start()
def __init__(self, parent, *args, **kwargs):
tk.Frame.__init__(self, parent)
self.parent = parent
self._state = UIState.Home
self.loading_details_visible = False
self.background_time = 60 * 15
self.background_max_requests = 5
self.background_images = []
self.base_image_path = os.getcwd() + "/UI/TV/Images/"
self.background_canvas = None
self.background_image = None
self.name_label = None
self.time_label = None
self.date_label = None
self.playing_label = None
self.playing_value = None
self.info_background = None
self.loading_speed_label = None
self.loading_buffered_label = None
self.loading_speed_value = None
self.loading_buffered_value = None
self.loading_peers_connected_label = None
self.loading_peers_connected_value = None
self.loading_peers_available_value = None
self.loading_peers_available_label = None
self.loading_gif = None
self.rects = []
self.images = []
self.player_frame = None
self.status_image_frame = None
self.pause_image = None
self.weather_max = None
self.weather_min = None
self.weather_temp = None
self.weather_icon_image = None
self.init_UI()
VLCPlayer().player_state.register_callback(self.player_update)
MediaManager().media_data.register_callback(self.media_update)
MediaManager().torrent_data.register_callback(self.torrent_update)
self.image_fetcher_thread = CustomThread(self.get_backgrounds,
"UI background downloader")
self.image_fetcher_thread.start()
self.background_swapper_thread = CustomThread(self.swap_backgrounds,
"UI background swapper")
self.background_swapper_thread.start()
self.time_change_thread = CustomThread(self.change_time,
"UI time changer")
self.time_change_thread.start()
self.current_weather_thread = CustomThread(self.get_weather_data,
"UI current weather")
self.current_weather_thread.start()
VLCPlayer().set_window(self.player_frame.winfo_id())
def request_master_cb(topic, callback, timeout, *args):
data = to_JSON(args)
request = SlaveClientController._send_request(topic, data)
thread = CustomThread(SlaveClientController.wait_for_request_response, "Request callback " + topic, [request, timeout, callback])
thread.start()
def observe_group(self, group):
Logger().write(LogVerbosity.All, "Starting observe for group " + group.name)
self.observe_thread = CustomThread(lambda: self.api(group.observe(
self.tradfri_state.update_group,
lambda x: self.check_observe(group), duration=30)), "Light group observer", [])
self.observe_thread.start()