diff --git a/mycroft/gui/extensions.py b/mycroft/gui/extensions.py
        self.supported_extensions = ["smartspeaker", "bigscreen", "generic"]

        if self.active_extension.lower() not in self.supported_extensions:
            self.active_extension = "generic"

        LOG.info(
            f"Extensions Manager: Initializing {self.name} with active extension {self.active_extension}")

        # map extension_id to class
        if extension_id == "smartspeaker":
            self.extension = SmartSpeakerExtension(self.bus, self.gui)
        elif extension_id == "bigscreen":
            self.extension = BigscreenExtension(self.bus, self.gui)
        else:
            self.extension = GenericExtension(self.bus, self.gui)

            self.bus.on("system.display.homescreen",
                        self.handle_system_display_homescreen)

        except Exception as e:
            LOG.error(f"SmartSpeaker: Init Bus Exception: {e}")

    def set_backend_type(self, message):
        backend = message.data.get("backend", "unknown")
        if not backend == "unknown":
            self.backend = backend
        else:
            backend = self._detect_backend()
            self.backend = backend

    def start_homescreen_process(self, message):
        self.device_paired = is_paired()
        if not self.backend == "local":
            self.homescreen_manager.show_homescreen()
            self.bus.emit(Message("ovos.shell.status.ok"))
        else:
            self.bus.emit(Message("ovos.shell.status.ok"))

    def _detect_backend(self):
        config = Configuration.get()
        server_config = config.get("server")
        backend_config = server_config.get("url")
        if "https://api.mycroft.ai" in backend_config:
            return "remote"
        else:
            return "local"

    def handle_remove_namespace(self, message):
        LOG.info("Got Clear Namespace Event In Skill")
        get_skill_namespace = message.data.get("skill_id", "")
        if get_skill_namespace:
            self.bus.emit(Message("gui.clear.namespace",
                                  {"__from": get_skill_namespace}))

    def handle_system_display_homescreen(self, message):
        self.homescreen_manager.show_homescreen()


 class BigscreenExtension():
            self.bus.on('gui.page_interaction', self.on_gui_page_interaction)
            self.bus.on('gui.namespace.removed', self.close_current_window)

        except Exception as e:
            LOG.error(f"Bigscreen: Init Bus Exception: {e}")

    def on_gui_page_show(self, message):
        override_idle = message.data.get('__idle')
        if override_idle is True:
            self.interaction_without_idle = True
        elif isinstance(override_idle, int) and not (override_idle, bool) and override_idle is not False:
            self.interaction_without_idle = True
        elif (message.data['page']):
            if not isinstance(override_idle, bool) or not isinstance(override_idle, int):
                self.interaction_without_idle = False

    def on_gui_page_interaction(self, message):
        skill_id = message.data.get('skill_id')
        self.interaction_skill_id = skill_id

    def handle_remove_namespace(self, message):
        get_skill_namespace = message.data.get("skill_id", "")
        LOG.info(f"Got Clear Namespace Event In Skill {get_skill_namespace}")
        if get_skill_namespace:
            self.bus.emit(Message("gui.clear.namespace",
                                  {"__from": get_skill_namespace}))

    def close_current_window(self, message):
        skill_id = message.data.get('skill_id')
        LOG.info(f"Bigscreen: Closing Current Window For Skill {skill_id}")
        self.bus.emit(Message('screen.close.idle.event',
                              data={"skill_idle_event_id": skill_id}))

    def close_window_by_event(self, message):
        self.interaction_without_idle = False
        self.bus.emit(Message('screen.close.idle.event',
                              data={"skill_idle_event_id": self.interaction_skill_id}))
        self.handle_remove_namespace(message)

    def close_window_by_force(self, message):
        skill_id = message.data.get('skill_id')
        self.bus.emit(Message('screen.close.idle.event',
                              data={"skill_idle_event_id": skill_id}))
        self.handle_remove_namespace(message)


 class GenericExtension():
        self.homescreen_supported = generic_config.get("homescreen_supported", False)

        if self.homescreen_supported:
            self.homescreen_manager = HomescreenManager(self.bus, self.gui)
            self.homescreen_thread = threading.Thread(
                target=self.homescreen_manager.run)
            self.homescreen_thread.start()

        try:
            self.bus.on("mycroft.gui.screen.close",
                        self.handle_remove_namespace)

        except Exception as e:
            LOG.error(f"Generic: Init Bus Exception: {e}")

    def handle_remove_namespace(self, message):
        LOG.info("Got Clear Namespace Event In Skill")
        get_skill_namespace = message.data.get("skill_id", "")
        if get_skill_namespace:
            self.bus.emit(Message("gui.clear.namespace",
                                  {"__from": get_skill_namespace}))
diff --git a/mycroft/gui/homescreen.py b/mycroft/gui/homescreen.py

    def add_homescreen(self, homescreen):
        # if homescreen[id] not in self.homescreens then add it
        homescreen_id = homescreen.data["id"]
        homescreen_class = homescreen.data["class"]
        LOG.info(f"Homescreen Manager: Adding Homescreen {homescreen_id}")
        # check if the list is empty
        if len(self.homescreens) == 0:
            self.homescreens.append(homescreen.data)
        else:
            # check if id is in list of homescreen dicts in self.homescreens
            for h in self.homescreens:
                if homescreen_id != h["id"]:
                    self.homescreens.append(homescreen.data)

        self.show_homescreen_on_add(homescreen_id, homescreen_class)

    def remove_homescreen(self, homescreen):
        homescreen_id = homescreen.data["id"]
        LOG.info(f"Homescreen Manager: Removing Homescreen {homescreen_id}")
        for h in self.homescreens:
            if homescreen_id == h["id"]:
                self.homescreens.pop(h)

    def get_homescreens(self):
        return self.homescreens

    def get_active_homescreen(self):
        config = Configuration.get()
        enclosure_config = config.get("gui")
        active_homescreen = enclosure_config.get("idle_display_skill")
        LOG.debug(f"Homescreen Manager: Active Homescreen {active_homescreen}")
        for h in self.homescreens:
            if h["id"] == active_homescreen:
                return active_homescreen

    def set_active_homescreen(self, homescreen):
        homescreen_id = homescreen.data["id"]
        conf = LocalConf(USER_CONFIG)
        conf["gui"] = {
            "idle_display_skill": homescreen_id,
        }
        conf.store()
        self.bus.emit(Message("configuration.patch", {"config": conf}))

    def reload_homescreens_list(self):
        LOG.info("Homescreen Manager: Reloading Homescreen List")
        self.bus.emit(Message("homescreen.manager.reload.list"))

    def show_homescreen_on_add(self, homescreen_id, homescreen_class):
        if self.mycroft_ready == True:
            active_homescreen = self.get_active_homescreen()
            if active_homescreen == homescreen_id:
                if homescreen_class == "IdleDisplaySkill":
                    LOG.debug(
                        f"Homescreen Manager: Displaying Homescreen {active_homescreen}")
                    self.bus.emit(Message("homescreen.manager.activate.display", {
                                  "homescreen_id": active_homescreen}))
                elif homescreen_class == "MycroftSkill":
                    LOG.debug(
                        f"Homescreen Manager: Displaying Homescreen {active_homescreen}")
                    self.bus.emit(Message("{}.idle".format(homescreen_id)))

    def disable_active_homescreen(self, message):
        conf = LocalConf(USER_CONFIG)
        conf["gui"] = {
            "idle_display_skill": None,
        }
        conf.store()
        self.bus.emit(Message("configuration.patch", {"config": conf}))

    def show_homescreen(self, message=None):
        active_homescreen = self.get_active_homescreen()
        for h in self.homescreens:
            if h["id"] == active_homescreen:
                if h["class"] == "IdleDisplaySkill":
                    LOG.debug(
                        f"Homescreen Manager: Displaying Homescreen {active_homescreen}")
                    self.bus.emit(Message("homescreen.manager.activate.display", {
                                  "homescreen_id": active_homescreen}))
                elif h["class"] == "MycroftSkill":
                    LOG.debug(
                        f"Homescreen Manager: Displaying Homescreen {active_homescreen}")
                    self.bus.emit(Message("{}.idle".format(active_homescreen)))

    def set_mycroft_ready(self, message):
        self.mycroft_ready = True
        self.show_homescreen()

    # Add compabitility with older versions of the Resting Screen Class

        self.bus.emit(Message("mycroft.mark2.collect_idle"))

    def register_old_style_homescreen(self, message):
        if "name" in message.data and "id" in message.data:
            super_class_name = "MycroftSkill"
            super_class_object = message.data["name"]
            skill_id = message.data["id"]
            _homescreen_entry = {"class": super_class_name,
                                 "name": super_class_object, "id": skill_id}
            LOG.debug("Homescreen Manager: Adding OLD Homescreen {skill_id}")
            self.add_homescreen(
                Message("homescreen.manager.add", _homescreen_entry))
        else:
            LOG.error("Malformed idle screen registration received")
diff --git a/mycroft/gui/namespace.py b/mycroft/gui/namespace.py
        Args:
            page_number: the page number of the page that will gain focus
        """
        LOG.info(
            f"Page {page_number} gained focus in GUI namespace {self.name}")
        self._activate_page(self.pages[page_number])

    def page_update_interaction(self, page_number):
        """Update the interaction of the page_number"""

        LOG.info(
            f"Page {page_number} update interaction in GUI namespace {self.name}")
        page = self.pages.index(page_number)
        if not page.persistent and page.duration > 0:
                    # check if there is a scheduled remove_namespace_timer and cancel it
                    if namespace.persistent:
                        if namespace.name in self.remove_namespace_timers:
                            self.remove_namespace_timers[namespace.name].cancel(
                            )
                            self._del_namespace_in_remove_timers(
                                namespace.name)

                if not namespace.persistent:
            self._remove_namespace_via_timer,
            args=(namespace.name,)
        )
        LOG.debug(
            f"Scheduled removal of namespace {namespace.name} in duration {namespace.duration}")
        remove_namespace_timer.start()
        self.remove_namespace_timers[namespace.name] = remove_namespace_timer
                               "skill_id": namespace.name}))
            if self.active_extension == "Bigscreen":
                # wait for window management in bigscreen extension to finish
                sleep(1)
            namespace_position = self.active_namespaces.index(namespace)
            namespace.remove(namespace_position)
            self.active_namespaces.remove(namespace)
        namespace = self._ensure_namespace_exists(namespace_name)
        for key, value in data.items():
            if key not in RESERVED_KEYS and namespace.data.get(key) != value:
                LOG.debug(
                    f"Setting {key} to {value} in namespace {namespace.name}")
                namespace.data[key] = value
                if namespace in self.active_namespaces:
diff --git a/mycroft/gui/service.py b/mycroft/gui/service.py
 from mycroft.configuration import Configuration, LocalConf, USER_CONFIG
 from mycroft.util.log import LOG
 from .namespace import NamespaceManager
 from mycroft.gui.extensions import ExtensionsManager


 class GUIService:
        # Allow exceptions to be raised to the GUI Service
        # if they may cause the Service to fail.
        start_message_bus_client("GUI_SERVICE", self.bus)
        extension_manager = ExtensionsManager(
            "EXTENSION_SERVICE", self.bus, self.gui)

    def stop(self):
diff --git a/mycroft/skills/__main__.py b/mycroft/skills/__main__.py
 from mycroft.skills.core import FallbackSkill
 from mycroft.skills.event_scheduler import EventScheduler
 from mycroft.skills.intent_service import IntentService
 from mycroft.skills.skill_manager import SkillManager, on_error, on_stopping, on_ready, on_alive, on_started
 from mycroft.util import (
    connected,
    reset_sigint_handler,
        config (dict): Mycroft configuration
    """

    def __init__(self, message_bus_client, config=None):
        config = config or Configuration.get()
        self.bus = message_bus_client
        self.platform = config['enclosure'].get("platform", "unknown")

    event_scheduler.setDaemon(True)
    event_scheduler.start()
    SkillApi.connect_bus(bus)
    skill_manager = SkillManager(bus, watchdog,
                                 alive_hook=alive_hook,
                                 started_hook=started_hook,
                                 stopping_hook=stopping_hook,
                                 ready_hook=ready_hook,
                                 error_hook=error_hook)

    device_primer = DevicePrimer(bus)
    skill_manager.start()
    device_primer.prepare_device()

    wait_for_exit_signal()

diff --git a/mycroft/skills/intent_services/converse_service.py b/mycroft/skills/intent_services/converse_service.py
                    want_converse.append(skill_id)
            skill_ids.append(skill_id)

        self.bus.on("skill.converse.pong", handle_ack)

        # wait for all skills to acknowledge they want to converse
        self.bus.emit(Message("skill.converse.ping"))
        start = time.time()
        while not all(s in skill_ids for s in active_skills) \
                and time.time() - start <= 0.5:
            time.sleep(0.02)

        self.bus.remove("skill.converse.pong", handle_ack)
        return want_converse

    def _check_converse_timeout(self):
diff --git a/mycroft/skills/skill_manager.py b/mycroft/skills/skill_manager.py


 def on_alive():
    LOG.info('Skills Manager is alive.')


 def on_ready():
    LOG.info('Skills Manager is ready.')


 def on_error(e='Unknown'):
    LOG.info(f'Skills Manager failed to launch ({e})')


 def on_stopping():
            else:
                LOG.error(f'Priority skill {skill_id} can\'t be found')

        self.status.set_alive()

    def run(self):
        """Load skills and update periodically from disk and internet."""
        self._remove_git_locks()

        self.load_priority()

        if self.skills_config.get("wait_for_internet", True):
            while not connected() and not self._connected_event.is_set():
            self.skill_updater.post_manifest()
            self._start_settings_update()

        self.status.set_ready()
        # Scan the file folder that contains Skills.  If a Skill is updated,
        # unload the existing version from memory and reload from the disk.
        while not self._stop_event.is_set():

    def is_alive(self, message=None):
        """Respond to is_alive status request."""
        return self.status.state >= ProcessState.ALIVE

    def is_all_loaded(self, message=None):
        """ Respond to all_loaded status request."""
        return self.status.state == ProcessState.READY

    def send_skill_list(self, _):
        """Send list of loaded skills."""
	self.supported_extensions = ["smartspeaker", "bigscreen", "generic"]

	if self.active_extension.lower() not in self.supported_extensions:
	self.active_extension = "generic"
Check warning on line 34 in mycroft/gui/extensions.py Codecov / codecov/patch mycroft/gui/extensions.py#L34 `Added line #L34 was not covered by tests`

	LOG.info(
	f"Extensions Manager: Initializing {self.name} with active extension {self.active_extension}")

	# map extension_id to class
	if extension_id == "smartspeaker":
	self.extension = SmartSpeakerExtension(self.bus, self.gui)
Check warning on line 45 in mycroft/gui/extensions.py Codecov / codecov/patch mycroft/gui/extensions.py#L45 `Added line #L45 was not covered by tests`
	elif extension_id == "bigscreen":
	self.extension = BigscreenExtension(self.bus, self.gui)
Check warning on line 47 in mycroft/gui/extensions.py Codecov / codecov/patch mycroft/gui/extensions.py#L47 `Added line #L47 was not covered by tests`
	else:
	self.extension = GenericExtension(self.bus, self.gui)

	self.bus.on("system.display.homescreen",
	self.handle_system_display_homescreen)

	except Exception as e:
	LOG.error(f"SmartSpeaker: Init Bus Exception: {e}")
Check warning on line 90 in mycroft/gui/extensions.py Codecov / codecov/patch mycroft/gui/extensions.py#L89-L90 `Added lines #L89 - L90 were not covered by tests`

	def set_backend_type(self, message):
	backend = message.data.get("backend", "unknown")
	if not backend == "unknown":
	self.backend = backend
Check warning on line 95 in mycroft/gui/extensions.py Codecov / codecov/patch mycroft/gui/extensions.py#L93-L95 `Added lines #L93 - L95 were not covered by tests`
	else:
	backend = self._detect_backend()
	self.backend = backend
Check warning on line 98 in mycroft/gui/extensions.py Codecov / codecov/patch mycroft/gui/extensions.py#L97-L98 `Added lines #L97 - L98 were not covered by tests`

	def start_homescreen_process(self, message):
	self.device_paired = is_paired()
	if not self.backend == "local":
	self.homescreen_manager.show_homescreen()
	self.bus.emit(Message("ovos.shell.status.ok"))
Check warning on line 104 in mycroft/gui/extensions.py Codecov / codecov/patch mycroft/gui/extensions.py#L101-L104 `Added lines #L101 - L104 were not covered by tests`
	else:
	self.bus.emit(Message("ovos.shell.status.ok"))
Check warning on line 106 in mycroft/gui/extensions.py Codecov / codecov/patch mycroft/gui/extensions.py#L106 `Added line #L106 was not covered by tests`

	def _detect_backend(self):
	config = Configuration.get()
	server_config = config.get("server")
	backend_config = server_config.get("url")
	if "https://api.mycroft.ai" in backend_config:
	return "remote"
Check warning on line 113 in mycroft/gui/extensions.py Codecov / codecov/patch mycroft/gui/extensions.py#L109-L113 `Added lines #L109 - L113 were not covered by tests`
	else:
	return "local"
Check warning on line 115 in mycroft/gui/extensions.py Codecov / codecov/patch mycroft/gui/extensions.py#L115 `Added line #L115 was not covered by tests`

	def handle_remove_namespace(self, message):
	LOG.info("Got Clear Namespace Event In Skill")
	get_skill_namespace = message.data.get("skill_id", "")
	if get_skill_namespace:
	self.bus.emit(Message("gui.clear.namespace",
Check warning on line 121 in mycroft/gui/extensions.py Codecov / codecov/patch mycroft/gui/extensions.py#L118-L121 `Added lines #L118 - L121 were not covered by tests`
	{"__from": get_skill_namespace}))

	def handle_system_display_homescreen(self, message):
	self.homescreen_manager.show_homescreen()
Check warning on line 125 in mycroft/gui/extensions.py Codecov / codecov/patch mycroft/gui/extensions.py#L125 `Added line #L125 was not covered by tests`


	class BigscreenExtension():
	self.bus.on('gui.page_interaction', self.on_gui_page_interaction)
	self.bus.on('gui.namespace.removed', self.close_current_window)

	except Exception as e:
	LOG.error(f"Bigscreen: Init Bus Exception: {e}")
Check warning on line 156 in mycroft/gui/extensions.py Codecov / codecov/patch mycroft/gui/extensions.py#L155-L156 `Added lines #L155 - L156 were not covered by tests`

	def on_gui_page_show(self, message):
	override_idle = message.data.get('__idle')
	if override_idle is True:
	self.interaction_without_idle = True
	elif isinstance(override_idle, int) and not (override_idle, bool) and override_idle is not False:
	self.interaction_without_idle = True
	elif (message.data['page']):
	if not isinstance(override_idle, bool) or not isinstance(override_idle, int):
	self.interaction_without_idle = False
Check warning on line 166 in mycroft/gui/extensions.py Codecov / codecov/patch mycroft/gui/extensions.py#L159-L166 `Added lines #L159 - L166 were not covered by tests`

	def on_gui_page_interaction(self, message):
	skill_id = message.data.get('skill_id')
	self.interaction_skill_id = skill_id
Check warning on line 170 in mycroft/gui/extensions.py Codecov / codecov/patch mycroft/gui/extensions.py#L169-L170 `Added lines #L169 - L170 were not covered by tests`

	def handle_remove_namespace(self, message):
	get_skill_namespace = message.data.get("skill_id", "")
	LOG.info(f"Got Clear Namespace Event In Skill {get_skill_namespace}")
	if get_skill_namespace:
	self.bus.emit(Message("gui.clear.namespace",
Check warning on line 176 in mycroft/gui/extensions.py Codecov / codecov/patch mycroft/gui/extensions.py#L173-L176 `Added lines #L173 - L176 were not covered by tests`
	{"__from": get_skill_namespace}))

	def close_current_window(self, message):
	skill_id = message.data.get('skill_id')
	LOG.info(f"Bigscreen: Closing Current Window For Skill {skill_id}")
	self.bus.emit(Message('screen.close.idle.event',
Check warning on line 182 in mycroft/gui/extensions.py Codecov / codecov/patch mycroft/gui/extensions.py#L180-L182 `Added lines #L180 - L182 were not covered by tests`
	data={"skill_idle_event_id": skill_id}))

	def close_window_by_event(self, message):
	self.interaction_without_idle = False
	self.bus.emit(Message('screen.close.idle.event',
Check warning on line 187 in mycroft/gui/extensions.py Codecov / codecov/patch mycroft/gui/extensions.py#L186-L187 `Added lines #L186 - L187 were not covered by tests`
	data={"skill_idle_event_id": self.interaction_skill_id}))
	self.handle_remove_namespace(message)
Check warning on line 189 in mycroft/gui/extensions.py Codecov / codecov/patch mycroft/gui/extensions.py#L189 `Added line #L189 was not covered by tests`

	def close_window_by_force(self, message):
	skill_id = message.data.get('skill_id')
	self.bus.emit(Message('screen.close.idle.event',
Check warning on line 193 in mycroft/gui/extensions.py Codecov / codecov/patch mycroft/gui/extensions.py#L192-L193 `Added lines #L192 - L193 were not covered by tests`
	data={"skill_idle_event_id": skill_id}))
	self.handle_remove_namespace(message)
Check warning on line 195 in mycroft/gui/extensions.py Codecov / codecov/patch mycroft/gui/extensions.py#L195 `Added line #L195 was not covered by tests`


	class GenericExtension():
	self.homescreen_supported = generic_config.get("homescreen_supported", False)

	if self.homescreen_supported:
	self.homescreen_manager = HomescreenManager(self.bus, self.gui)
	self.homescreen_thread = threading.Thread(
Check warning on line 221 in mycroft/gui/extensions.py Codecov / codecov/patch mycroft/gui/extensions.py#L220-L221 `Added lines #L220 - L221 were not covered by tests`
	target=self.homescreen_manager.run)
	self.homescreen_thread.start()
Check warning on line 223 in mycroft/gui/extensions.py Codecov / codecov/patch mycroft/gui/extensions.py#L223 `Added line #L223 was not covered by tests`

	try:
	self.bus.on("mycroft.gui.screen.close",
	self.handle_remove_namespace)

	except Exception as e:
	LOG.error(f"Generic: Init Bus Exception: {e}")
Check warning on line 230 in mycroft/gui/extensions.py Codecov / codecov/patch mycroft/gui/extensions.py#L229-L230 `Added lines #L229 - L230 were not covered by tests`

	def handle_remove_namespace(self, message):
	LOG.info("Got Clear Namespace Event In Skill")
	get_skill_namespace = message.data.get("skill_id", "")
	if get_skill_namespace:
	self.bus.emit(Message("gui.clear.namespace",
Check warning on line 236 in mycroft/gui/extensions.py Codecov / codecov/patch mycroft/gui/extensions.py#L233-L236 `Added lines #L233 - L236 were not covered by tests`
	{"__from": get_skill_namespace}))

	def add_homescreen(self, homescreen):
	# if homescreen[id] not in self.homescreens then add it
	homescreen_id = homescreen.data["id"]
	homescreen_class = homescreen.data["class"]
	LOG.info(f"Homescreen Manager: Adding Homescreen {homescreen_id}")
Check warning on line 36 in mycroft/gui/homescreen.py Codecov / codecov/patch mycroft/gui/homescreen.py#L34-L36 `Added lines #L34 - L36 were not covered by tests`
	# check if the list is empty
	if len(self.homescreens) == 0:
	self.homescreens.append(homescreen.data)
Check warning on line 39 in mycroft/gui/homescreen.py Codecov / codecov/patch mycroft/gui/homescreen.py#L38-L39 `Added lines #L38 - L39 were not covered by tests`
	else:
	# check if id is in list of homescreen dicts in self.homescreens
	for h in self.homescreens:
	if homescreen_id != h["id"]:
	self.homescreens.append(homescreen.data)
Check warning on line 44 in mycroft/gui/homescreen.py Codecov / codecov/patch mycroft/gui/homescreen.py#L42-L44 `Added lines #L42 - L44 were not covered by tests`

	self.show_homescreen_on_add(homescreen_id, homescreen_class)
Check warning on line 46 in mycroft/gui/homescreen.py Codecov / codecov/patch mycroft/gui/homescreen.py#L46 `Added line #L46 was not covered by tests`

	def remove_homescreen(self, homescreen):
	homescreen_id = homescreen.data["id"]
	LOG.info(f"Homescreen Manager: Removing Homescreen {homescreen_id}")
	for h in self.homescreens:
	if homescreen_id == h["id"]:
	self.homescreens.pop(h)
Check warning on line 53 in mycroft/gui/homescreen.py Codecov / codecov/patch mycroft/gui/homescreen.py#L49-L53 `Added lines #L49 - L53 were not covered by tests`

	def get_homescreens(self):
	return self.homescreens
Check warning on line 56 in mycroft/gui/homescreen.py Codecov / codecov/patch mycroft/gui/homescreen.py#L56 `Added line #L56 was not covered by tests`

	def get_active_homescreen(self):
	config = Configuration.get()
	enclosure_config = config.get("gui")
	active_homescreen = enclosure_config.get("idle_display_skill")
	LOG.debug(f"Homescreen Manager: Active Homescreen {active_homescreen}")
	for h in self.homescreens:
	if h["id"] == active_homescreen:
	return active_homescreen
Check warning on line 65 in mycroft/gui/homescreen.py Codecov / codecov/patch mycroft/gui/homescreen.py#L59-L65 `Added lines #L59 - L65 were not covered by tests`

	def set_active_homescreen(self, homescreen):
	homescreen_id = homescreen.data["id"]
	conf = LocalConf(USER_CONFIG)
	conf["gui"] = {
Check warning on line 70 in mycroft/gui/homescreen.py Codecov / codecov/patch mycroft/gui/homescreen.py#L68-L70 `Added lines #L68 - L70 were not covered by tests`
	"idle_display_skill": homescreen_id,
	}
	conf.store()
	self.bus.emit(Message("configuration.patch", {"config": conf}))
Check warning on line 74 in mycroft/gui/homescreen.py Codecov / codecov/patch mycroft/gui/homescreen.py#L73-L74 `Added lines #L73 - L74 were not covered by tests`

	def reload_homescreens_list(self):
	LOG.info("Homescreen Manager: Reloading Homescreen List")
	self.bus.emit(Message("homescreen.manager.reload.list"))

	def show_homescreen_on_add(self, homescreen_id, homescreen_class):
	if self.mycroft_ready == True:
	active_homescreen = self.get_active_homescreen()
	if active_homescreen == homescreen_id:
	if homescreen_class == "IdleDisplaySkill":
	LOG.debug(
Check warning on line 86 in mycroft/gui/homescreen.py Codecov / codecov/patch mycroft/gui/homescreen.py#L82-L86 `Added lines #L82 - L86 were not covered by tests`
	f"Homescreen Manager: Displaying Homescreen {active_homescreen}")
	self.bus.emit(Message("homescreen.manager.activate.display", {
Check warning on line 88 in mycroft/gui/homescreen.py Codecov / codecov/patch mycroft/gui/homescreen.py#L88 `Added line #L88 was not covered by tests`
	"homescreen_id": active_homescreen}))
	elif homescreen_class == "MycroftSkill":
	LOG.debug(
Check warning on line 91 in mycroft/gui/homescreen.py Codecov / codecov/patch mycroft/gui/homescreen.py#L90-L91 `Added lines #L90 - L91 were not covered by tests`
	f"Homescreen Manager: Displaying Homescreen {active_homescreen}")
	self.bus.emit(Message("{}.idle".format(homescreen_id)))
Check warning on line 93 in mycroft/gui/homescreen.py Codecov / codecov/patch mycroft/gui/homescreen.py#L93 `Added line #L93 was not covered by tests`

	def disable_active_homescreen(self, message):
	conf = LocalConf(USER_CONFIG)
	conf["gui"] = {
Check warning on line 97 in mycroft/gui/homescreen.py Codecov / codecov/patch mycroft/gui/homescreen.py#L96-L97 `Added lines #L96 - L97 were not covered by tests`
	"idle_display_skill": None,
	}
	conf.store()
	self.bus.emit(Message("configuration.patch", {"config": conf}))
Check warning on line 101 in mycroft/gui/homescreen.py Codecov / codecov/patch mycroft/gui/homescreen.py#L100-L101 `Added lines #L100 - L101 were not covered by tests`

	def show_homescreen(self, message=None):
	active_homescreen = self.get_active_homescreen()
	for h in self.homescreens:
	if h["id"] == active_homescreen:
	if h["class"] == "IdleDisplaySkill":
	LOG.debug(
Check warning on line 108 in mycroft/gui/homescreen.py Codecov / codecov/patch mycroft/gui/homescreen.py#L104-L108 `Added lines #L104 - L108 were not covered by tests`
	f"Homescreen Manager: Displaying Homescreen {active_homescreen}")
	self.bus.emit(Message("homescreen.manager.activate.display", {
Check warning on line 110 in mycroft/gui/homescreen.py Codecov / codecov/patch mycroft/gui/homescreen.py#L110 `Added line #L110 was not covered by tests`
	"homescreen_id": active_homescreen}))
	elif h["class"] == "MycroftSkill":
	LOG.debug(
Check warning on line 113 in mycroft/gui/homescreen.py Codecov / codecov/patch mycroft/gui/homescreen.py#L112-L113 `Added lines #L112 - L113 were not covered by tests`
	f"Homescreen Manager: Displaying Homescreen {active_homescreen}")
	self.bus.emit(Message("{}.idle".format(active_homescreen)))
Check warning on line 115 in mycroft/gui/homescreen.py Codecov / codecov/patch mycroft/gui/homescreen.py#L115 `Added line #L115 was not covered by tests`

	def set_mycroft_ready(self, message):
	self.mycroft_ready = True
	self.show_homescreen()
Check warning on line 119 in mycroft/gui/homescreen.py Codecov / codecov/patch mycroft/gui/homescreen.py#L118-L119 `Added lines #L118 - L119 were not covered by tests`

	# Add compabitility with older versions of the Resting Screen Class

	self.bus.emit(Message("mycroft.mark2.collect_idle"))

	def register_old_style_homescreen(self, message):
	if "name" in message.data and "id" in message.data:
	super_class_name = "MycroftSkill"
	super_class_object = message.data["name"]
	skill_id = message.data["id"]
	_homescreen_entry = {"class": super_class_name,
Check warning on line 132 in mycroft/gui/homescreen.py Codecov / codecov/patch mycroft/gui/homescreen.py#L128-L132 `Added lines #L128 - L132 were not covered by tests`
	"name": super_class_object, "id": skill_id}
	LOG.debug("Homescreen Manager: Adding OLD Homescreen {skill_id}")
	self.add_homescreen(
Check warning on line 135 in mycroft/gui/homescreen.py Codecov / codecov/patch mycroft/gui/homescreen.py#L134-L135 `Added lines #L134 - L135 were not covered by tests`
	Message("homescreen.manager.add", _homescreen_entry))
	else:
	LOG.error("Malformed idle screen registration received")
Check warning on line 138 in mycroft/gui/homescreen.py Codecov / codecov/patch mycroft/gui/homescreen.py#L138 `Added line #L138 was not covered by tests`
	Args:
	page_number: the page number of the page that will gain focus
	"""
	LOG.info(
Check warning on line 308 in mycroft/gui/namespace.py Codecov / codecov/patch mycroft/gui/namespace.py#L308 `Added line #L308 was not covered by tests`
	f"Page {page_number} gained focus in GUI namespace {self.name}")
	self._activate_page(self.pages[page_number])

	def page_update_interaction(self, page_number):
	"""Update the interaction of the page_number"""

	LOG.info(
Check warning on line 315 in mycroft/gui/namespace.py Codecov / codecov/patch mycroft/gui/namespace.py#L315 `Added line #L315 was not covered by tests`
	f"Page {page_number} update interaction in GUI namespace {self.name}")
	page = self.pages.index(page_number)
	if not page.persistent and page.duration > 0:
	# check if there is a scheduled remove_namespace_timer and cancel it
	if namespace.persistent:
	if namespace.name in self.remove_namespace_timers:
	self.remove_namespace_timers[namespace.name].cancel(
Check warning on line 608 in mycroft/gui/namespace.py Codecov / codecov/patch mycroft/gui/namespace.py#L608 `Added line #L608 was not covered by tests`
	)
	self._del_namespace_in_remove_timers(
Check warning on line 610 in mycroft/gui/namespace.py Codecov / codecov/patch mycroft/gui/namespace.py#L610 `Added line #L610 was not covered by tests`
	namespace.name)

	if not namespace.persistent:
	self._remove_namespace_via_timer,
	args=(namespace.name,)
	)
	LOG.debug(
Check warning on line 632 in mycroft/gui/namespace.py Codecov / codecov/patch mycroft/gui/namespace.py#L632 `Added line #L632 was not covered by tests`
	f"Scheduled removal of namespace {namespace.name} in duration {namespace.duration}")
	remove_namespace_timer.start()
	self.remove_namespace_timers[namespace.name] = remove_namespace_timer
	"skill_id": namespace.name}))
	if self.active_extension == "Bigscreen":
	# wait for window management in bigscreen extension to finish
	sleep(1)
Check warning on line 661 in mycroft/gui/namespace.py Codecov / codecov/patch mycroft/gui/namespace.py#L661 `Added line #L661 was not covered by tests`
	namespace_position = self.active_namespaces.index(namespace)
	namespace.remove(namespace_position)
	self.active_namespaces.remove(namespace)
	namespace = self._ensure_namespace_exists(namespace_name)
	for key, value in data.items():
	if key not in RESERVED_KEYS and namespace.data.get(key) != value:
	LOG.debug(
Check warning on line 715 in mycroft/gui/namespace.py Codecov / codecov/patch mycroft/gui/namespace.py#L715 `Added line #L715 was not covered by tests`
	f"Setting {key} to {value} in namespace {namespace.name}")
	namespace.data[key] = value
	if namespace in self.active_namespaces:
	from mycroft.configuration import Configuration, LocalConf, USER_CONFIG
	from mycroft.util.log import LOG
	from .namespace import NamespaceManager
	from mycroft.gui.extensions import ExtensionsManager
Check warning on line 7 in mycroft/gui/service.py Codecov / codecov/patch mycroft/gui/service.py#L7 `Added line #L7 was not covered by tests`


	class GUIService:
	# Allow exceptions to be raised to the GUI Service
	# if they may cause the Service to fail.
	start_message_bus_client("GUI_SERVICE", self.bus)
	extension_manager = ExtensionsManager(
Check warning on line 20 in mycroft/gui/service.py Codecov / codecov/patch mycroft/gui/service.py#L20 `Added line #L20 was not covered by tests`
	"EXTENSION_SERVICE", self.bus, self.gui)

	def stop(self):
	from mycroft.skills.core import FallbackSkill
	from mycroft.skills.event_scheduler import EventScheduler
	from mycroft.skills.intent_service import IntentService
	from mycroft.skills.skill_manager import SkillManager, on_error, on_stopping, on_ready, on_alive, on_started
Check warning on line 34 in mycroft/skills/__main__.py Codecov / codecov/patch mycroft/skills/__main__.py#L34 `Added line #L34 was not covered by tests`
	from mycroft.util import (
	connected,
	reset_sigint_handler,
	config (dict): Mycroft configuration
	"""

	def __init__(self, message_bus_client, config=None):
	config = config or Configuration.get()
Check warning on line 56 in mycroft/skills/__main__.py Codecov / codecov/patch mycroft/skills/__main__.py#L55-L56 `Added lines #L55 - L56 were not covered by tests`
	self.bus = message_bus_client
	self.platform = config['enclosure'].get("platform", "unknown")

	event_scheduler.setDaemon(True)
	event_scheduler.start()
	SkillApi.connect_bus(bus)
	skill_manager = SkillManager(bus, watchdog,
Check warning on line 206 in mycroft/skills/__main__.py Codecov / codecov/patch mycroft/skills/__main__.py#L206 `Added line #L206 was not covered by tests`
	alive_hook=alive_hook,
	started_hook=started_hook,
	stopping_hook=stopping_hook,
	ready_hook=ready_hook,
	error_hook=error_hook)

	device_primer = DevicePrimer(bus)
Check warning on line 213 in mycroft/skills/__main__.py Codecov / codecov/patch mycroft/skills/__main__.py#L213 `Added line #L213 was not covered by tests`
	skill_manager.start()
	device_primer.prepare_device()
Check warning on line 215 in mycroft/skills/__main__.py Codecov / codecov/patch mycroft/skills/__main__.py#L215 `Added line #L215 was not covered by tests`

	wait_for_exit_signal()
	want_converse.append(skill_id)
	skill_ids.append(skill_id)

	self.bus.on("skill.converse.pong", handle_ack)
Check warning on line 197 in mycroft/skills/intent_services/converse_service.py Codecov / codecov/patch mycroft/skills/intent_services/converse_service.py#L197 `Added line #L197 was not covered by tests`

	# wait for all skills to acknowledge they want to converse
	self.bus.emit(Message("skill.converse.ping"))
Check warning on line 200 in mycroft/skills/intent_services/converse_service.py Codecov / codecov/patch mycroft/skills/intent_services/converse_service.py#L200 `Added line #L200 was not covered by tests`
	start = time.time()
	while not all(s in skill_ids for s in active_skills) \
	and time.time() - start <= 0.5:
	time.sleep(0.02)

	self.bus.remove("skill.converse.pong", handle_ack)
Check warning on line 206 in mycroft/skills/intent_services/converse_service.py Codecov / codecov/patch mycroft/skills/intent_services/converse_service.py#L206 `Added line #L206 was not covered by tests`
	return want_converse

	def _check_converse_timeout(self):


	def on_alive():
	LOG.info('Skills Manager is alive.')
Check warning on line 118 in mycroft/skills/skill_manager.py Codecov / codecov/patch mycroft/skills/skill_manager.py#L118 `Added line #L118 was not covered by tests`


	def on_ready():
	LOG.info('Skills Manager is ready.')
Check warning on line 122 in mycroft/skills/skill_manager.py Codecov / codecov/patch mycroft/skills/skill_manager.py#L122 `Added line #L122 was not covered by tests`


	def on_error(e='Unknown'):
	LOG.info(f'Skills Manager failed to launch ({e})')
Check warning on line 126 in mycroft/skills/skill_manager.py Codecov / codecov/patch mycroft/skills/skill_manager.py#L126 `Added line #L126 was not covered by tests`


	def on_stopping():
	else:
	LOG.error(f'Priority skill {skill_id} can\'t be found')

	self.status.set_alive()
Check warning on line 313 in mycroft/skills/skill_manager.py Codecov / codecov/patch mycroft/skills/skill_manager.py#L313 `Added line #L313 was not covered by tests`

	def run(self):
	"""Load skills and update periodically from disk and internet."""
	self._remove_git_locks()

	self.load_priority()
Check warning on line 319 in mycroft/skills/skill_manager.py Codecov / codecov/patch mycroft/skills/skill_manager.py#L319 `Added line #L319 was not covered by tests`

	if self.skills_config.get("wait_for_internet", True):
	while not connected() and not self._connected_event.is_set():
	self.skill_updater.post_manifest()
	self._start_settings_update()

	self.status.set_ready()
Check warning on line 333 in mycroft/skills/skill_manager.py Codecov / codecov/patch mycroft/skills/skill_manager.py#L333 `Added line #L333 was not covered by tests`
	# Scan the file folder that contains Skills. If a Skill is updated,
	# unload the existing version from memory and reload from the disk.
	while not self._stop_event.is_set():

	def is_alive(self, message=None):
	"""Respond to is_alive status request."""
	return self.status.state >= ProcessState.ALIVE
Check warning on line 490 in mycroft/skills/skill_manager.py Codecov / codecov/patch mycroft/skills/skill_manager.py#L490 `Added line #L490 was not covered by tests`

	def is_all_loaded(self, message=None):
	""" Respond to all_loaded status request."""
	return self.status.state == ProcessState.READY
Check warning on line 494 in mycroft/skills/skill_manager.py Codecov / codecov/patch mycroft/skills/skill_manager.py#L494 `Added line #L494 was not covered by tests`

	def send_skill_list(self, _):
	"""Send list of loaded skills."""