Beispiel #1
0
    def test_get_edid_name_cache(self, monkeypatch):
        """
        Tests that the get_edid_name function returns the correct cached values.

        It explicitly sets the cache for the function and mocks the "live" model such
        that if the cache isn't respected, it would return the "live" model.

        Args:
            monkeypatch - pytest fixture which gives mocking functionality
            edid - parameterised fixture containing raw, rpi_dumps, expected test data
        """
        cached_screen_name = 'CHACHE-SCR'
        live_screen_name = 'LIVE-SCR'

        # Mock the run_cmd function such that it returns the cached screen name and
        # call the function to explicitly set the cache.
        monkeypatch.setattr(display, 'run_cmd', lambda x:
                            (cached_screen_name, '', 0))
        display.get_edid_name(use_cached=False)

        # Mock the run_cmd function such that it returns the "live" screen name and
        # get the cached and live values from the function.
        monkeypatch.setattr(display, 'run_cmd', lambda x:
                            (live_screen_name, '', 0))
        rv_cache = display.get_edid_name(use_cached=True)
        rv_no_cache = display.get_edid_name(use_cached=False)

        assert (rv_cache == cached_screen_name
                and rv_no_cache == live_screen_name)
    def test_get_edid_name_cache(self, monkeypatch):
        """
        Tests that the get_edid_name function returns the correct cached values.

        It explicitly sets the cache for the function and mocks the "live" model such
        that if the cache isn't respected, it would return the "live" model.

        Args:
            monkeypatch - pytest fixture which gives mocking functionality
            edid - parameterised fixture containing raw, rpi_dumps, expected test data
        """

        from kano_settings.system import display

        cached_screen_name = 'CHACHE-SCR'
        live_screen_name = 'LIVE-SCR'

        # Mock the run_cmd function such that it returns the cached screen name and
        # call the function to explicitly set the cache.
        monkeypatch.setattr(
            display, 'run_cmd',
            lambda x: (cached_screen_name, '', 0)
        )
        display.get_edid_name(use_cached=False)

        # Mock the run_cmd function such that it returns the "live" screen name and
        # get the cached and live values from the function.
        monkeypatch.setattr(
            display, 'run_cmd',
            lambda x: (live_screen_name, '', 0)
        )
        rv_cache = display.get_edid_name(use_cached=True)
        rv_no_cache = display.get_edid_name(use_cached=False)

        assert(rv_cache == cached_screen_name and rv_no_cache == live_screen_name)
Beispiel #3
0
    def test_get_cached_edid(self):
        with patched_run_cmd(self.VALID_DISPLAY_NAME):
            edid = display.get_edid_name(use_cached=True)

        self.assertEqual(edid, self.VALID_EDID_VAL)

        edid = display.get_edid_name(use_cached=True)
        self.assertEqual(edid, self.VALID_EDID_VAL)
def get_screen_log():
    """Get display information using kano-settings display functions.

    Returns:
        dict: An aggregate of display characteristics
    """

    try:
        from kano_settings.system.display import get_edid, get_edid_name, get_status, \
            list_supported_modes, get_optimal_resolution_mode, override_models

        edid = get_edid()
        model = get_edid_name(use_cached=False)

        override_models(edid, model)

        status = get_status()
        supported = list_supported_modes(use_cached=False)
        optimal = get_optimal_resolution_mode(edid, supported)

        log_data = {
            'model': model,
            'status': status,
            'edid': edid,
            'supported': supported,
            'optimal': optimal,
        }
        log = json.dumps(log_data, sort_keys=True, indent=4)
    except:
        return traceback.format_exc()

    return log
Beispiel #5
0
def get_screen_log():
    """Get display information using kano-settings display functions.

    Returns:
        dict: An aggregate of display characteristics
    """

    try:
        from kano_settings.system.display import get_edid, get_edid_name, get_status, \
            list_supported_modes, get_optimal_resolution_mode, override_models

        edid = get_edid()
        model = get_edid_name(use_cached=False)

        override_models(edid, model)

        status = get_status()
        supported = list_supported_modes(use_cached=False)
        optimal = get_optimal_resolution_mode(edid, supported)

        log_data = {
            'model': model,
            'status': status,
            'edid': edid,
            'supported': supported,
            'optimal': optimal,
        }
        log = json.dumps(log_data, sort_keys=True, indent=4)
    except:
        return traceback.format_exc()

    return log
    def test_get_edid_name(self, monkeypatch, edid):
        """
        Tests that the get_edid_name function returns the correct display model.

        Args:
            monkeypatch - pytest fixture which gives mocking functionality
            edid - parameterised fixture containing raw, rpi_dumps, expected test data
        """

        try:
            from kano_settings.system import display
        except RuntimeError as err:
            pytest.skip(
                'FIXME: RuntimeError: `kano_settings.system.display import ' \
                'fails randomly when Pytest decides to fiddle around with ' \
                'threads.\n{}'.format(err)
            )

        # Mock the run_cmd function such that it returns the dump for the device name.
        monkeypatch.setattr(
            display, 'run_cmd',
            lambda x: (edid['rpi_dumps']['device_name'], '', 0)
        )
        rv = display.get_edid_name(use_cached=False)

        assert(rv == edid['expected']['model'])
    def test_get_edid_name(self, monkeypatch, edid):
        """
        Tests that the get_edid_name function returns the correct display model.

        Args:
            monkeypatch - pytest fixture which gives mocking functionality
            edid - parameterised fixture containing raw, rpi_dumps, expected test data
        """

        try:
            from kano_settings.system import display
        except RuntimeError as err:
            pytest.skip(
                'FIXME: RuntimeError: `kano_settings.system.display import ' \
                'fails randomly when Pytest decides to fiddle around with ' \
                'threads.\n{}'.format(err)
            )

        # Mock the run_cmd function such that it returns the dump for the device name.
        monkeypatch.setattr(
            display, 'run_cmd', lambda x:
            (edid['rpi_dumps']['device_name'], '', 0))
        rv = display.get_edid_name(use_cached=False)

        assert (rv == edid['expected']['model'])
Beispiel #8
0
    def set_hdmi_mode_from_str(self, mode):
        if mode == 'auto':
            if get_edid_name():
                set_hdmi_mode()
            else:
                set_unflashed_sk_resolution()
            return

        group, number = mode.split(":")
        set_hdmi_mode(group, number)
    def set_hdmi_mode_from_str(self, mode):
        if mode == 'auto':
            if get_edid_name():
                set_hdmi_mode()
            else:
                set_unflashed_sk_resolution()
            return

        group, number = mode.split(":")
        set_hdmi_mode(group, number)
Beispiel #10
0
def get_screen_version():
    '''Retrieves the kit type and version from the EDID data

    Returns:
        (int, distutils.version.LooseVersion):
                Tuple of the kit identifier and the version associated
                with that kit. If this fails, (None, None) is returned
    '''
    edid_model = get_edid_name()

    return EDID_MAP.get(edid_model, (None, None))
Beispiel #11
0
    def test_get_edid_name(self, monkeypatch, edid):
        """
        Tests that the get_edid_name function returns the correct display model.

        Args:
            monkeypatch - pytest fixture which gives mocking functionality
            edid - parameterised fixture containing raw, rpi_dumps, expected test data
        """

        # Mock the run_cmd function such that it returns the dump for the device name.
        monkeypatch.setattr(
            display, 'run_cmd', lambda x:
            (edid['rpi_dumps']['device_name'], '', 0))
        rv = display.get_edid_name(use_cached=False)

        assert (rv == edid['expected']['model'])
Beispiel #12
0
    def __init__(self, win):
        # Show the Display brand and model
        self.model = get_edid_name()
        info_message = _("\nScreen Model: {}".format(self.model))

        # And the current display resolution
        try:
            current_resolution = get_status()['resolution']
            info_message += _("\nCurrent Resolution: {}").format(_(current_resolution))
        except:
            pass

        Template.__init__(
            self,
            _("Display"),
            info_message,
            _("APPLY CHANGES")
        )

        self.win = win
        self.win.set_main_widget(self)

        self.win.top_bar.enable_prev()
        self.win.change_prev_callback(self.win.go_to_home)

        self.kano_button.connect('button-release-event', self.apply_changes)
        self.kano_button.connect('key-release-event', self.apply_changes)

        horizontal_container = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL,
                                       spacing=40)
        horizontal_container.set_valign(Gtk.Align.CENTER)

        # HDMI mode combo box
        self.mode_combo = KanoComboBox(max_display_items=7)
        self.mode_combo.connect('changed', self.on_mode_changed)

        # Fill list of modes
        modes = list_supported_modes()
        self.mode_combo.append('auto')
        mode_string = '{hdmi_group}:{hdmi_mode}  {width}x{height}  {refresh_rate}Hz  {aspect_ratio}'

        if modes:
            for mode in modes:
                self.mode_combo.append(mode_string.format(
                    hdmi_group=mode['group'],
                    hdmi_mode=mode['mode'],
                    width=mode['width'],
                    height=mode['height'],
                    refresh_rate=mode['rate'],
                    aspect_ratio=mode['aspect_ratio']
                ))

        horizontal_container.pack_start(self.mode_combo, False, False, 0)
        self.mode_combo.props.valign = Gtk.Align.CENTER

        # Select the current setting in the dropdown list
        saved_group, saved_mode = read_hdmi_mode()
        active_item = find_matching_mode(modes, saved_group, saved_mode)
        self.mode_combo.set_selected_item_index(active_item)
        self.init_item = active_item
        self.mode_index = active_item
        # Overscan button
        overscan_button = OrangeButton(_("Overscan"))
        horizontal_container.pack_end(overscan_button, False, False, 0)
        overscan_button.connect('button-release-event', self.go_to_overscan)

        self.box.pack_start(horizontal_container, False, False, 0)

        # Create Flip 180 checkbox
        flip_button = Gtk.CheckButton(_("Flip Screen"))
        flip_button.set_can_focus(False)
        flip_button.props.valign = Gtk.Align.CENTER
        flip_button.set_active(get_screen_value('display_rotate') == 2)
        flip_button.connect('clicked', self.flip)

        self.box.pack_start(flip_button, False, False, 0)
        self.kano_button.set_sensitive(False)

        # Add apply changes button under the main settings content
        self.win.show_all()
Beispiel #13
0
    def test_get_failure(self):
        with patched_run_cmd('unused', returncode=1):
            edid = display.get_edid_name(use_cached=False)

        self.assertEqual(edid, None)
Beispiel #14
0
    def test_get_empty_edid(self):
        with patched_run_cmd(self.EMPTY_DISPLAY_NAME):
            edid = display.get_edid_name(use_cached=False)

        self.assertEqual(edid, self.EMPTY_EDID_VAL)
    def __init__(self, win):
        # Show the Display brand and model
        self.model = get_edid_name()
        info_message = _("\nScreen Model: {}".format(self.model))

        # And the current display resolution
        try:
            current_resolution = get_status()['resolution']
            info_message += _("\nCurrent Resolution: {}").format(_(current_resolution))
        except:
            pass

        Template.__init__(
            self,
            _("Display"),
            info_message,
            _("APPLY CHANGES")
        )

        self.win = win
        self.win.set_main_widget(self)

        self.win.top_bar.enable_prev()
        self.win.change_prev_callback(self.win.go_to_home)

        self.kano_button.connect('button-release-event', self.apply_changes)
        self.kano_button.connect('key-release-event', self.apply_changes)

        horizontal_container = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL,
                                       spacing=40)
        horizontal_container.set_valign(Gtk.Align.CENTER)

        # HDMI mode combo box
        self.mode_combo = KanoComboBox(max_display_items=7)
        self.mode_combo.connect('changed', self.on_mode_changed)

        # Fill list of modes
        modes = list_supported_modes()
        self.mode_combo.append('auto')
        mode_string = '{hdmi_group}:{hdmi_mode}  {width}x{height}  {refresh_rate}Hz  {aspect_ratio}'

        if modes:
            for mode in modes:
                self.mode_combo.append(mode_string.format(
                    hdmi_group=mode['group'],
                    hdmi_mode=mode['mode'],
                    width=mode['width'],
                    height=mode['height'],
                    refresh_rate=mode['rate'],
                    aspect_ratio=mode['aspect_ratio']
                ))

        horizontal_container.pack_start(self.mode_combo, False, False, 0)
        self.mode_combo.props.valign = Gtk.Align.CENTER

        # Select the current setting in the dropdown list
        saved_group, saved_mode = read_hdmi_mode()
        active_item = find_matching_mode(modes, saved_group, saved_mode)
        self.mode_combo.set_selected_item_index(active_item)
        self.init_item = active_item
        self.mode_index = active_item
        # Overscan button
        overscan_button = OrangeButton(_("Overscan"))
        horizontal_container.pack_end(overscan_button, False, False, 0)
        overscan_button.connect('button-release-event', self.go_to_overscan)

        self.box.pack_start(horizontal_container, False, False, 0)

        # Create Flip 180 checkbox
        flip_button = Gtk.CheckButton(_("Flip Screen"))
        flip_button.set_can_focus(False)
        flip_button.props.valign = Gtk.Align.CENTER
        self.flip_preference_start = (get_screen_value('display_rotate') == 2)
        self.flip_preference_end = self.flip_preference_start
        flip_button.set_active(self.flip_preference_start)
        flip_button.connect('clicked', self.on_flip_screen_clicked)

        self.box.pack_start(flip_button, False, False, 0)
        self.kano_button.set_sensitive(False)

        # Add apply changes button under the main settings content
        self.win.show_all()