| # Lint as: python2, python3 |
| # Copyright 2021 The Chromium OS Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| import abc |
| import logging |
| import six |
| |
| from autotest_lib.client.common_lib import error |
| |
| |
| @six.add_metaclass(abc.ABCMeta) |
| class _BaseMenuModeSwitcher: |
| """ |
| Base class for mode switch with menu navigator. |
| """ |
| |
| def __init__(self, faft_framework, menu_navigator): |
| self.test = faft_framework |
| self.faft_config = self.test.faft_config |
| self.servo = self.test.servo |
| self.menu = menu_navigator |
| self.checkers = faft_framework.checkers |
| |
| self.minidiag_enabled = self.faft_config.minidiag_enabled |
| self.minios_enabled = self.faft_config.minios_enabled |
| |
| @abc.abstractmethod |
| def trigger_rec_to_dev(self): |
| """ |
| Trigger to-dev transition. |
| """ |
| raise NotImplementedError |
| |
| @abc.abstractmethod |
| def dev_boot_from_internal(self): |
| """ |
| Boot from internal disk in developer mode. |
| """ |
| raise NotImplementedError |
| |
| @abc.abstractmethod |
| def dev_boot_from_external(self): |
| """Boot from external disk in developer mode.""" |
| raise NotImplementedError |
| |
| @abc.abstractmethod |
| def trigger_dev_to_normal(self): |
| """ |
| Trigger dev-to-norm transition. |
| """ |
| raise NotImplementedError |
| |
| @abc.abstractmethod |
| def power_off(self): |
| """ |
| Power off the device. |
| |
| This method should work in both developer and recovery screens. |
| """ |
| raise NotImplementedError |
| |
| |
| class _TabletDetachableMenuModeSwitcher(_BaseMenuModeSwitcher): |
| """ |
| Mode switcher with menu navigator for legacy menu UI. |
| |
| The "legacy menu UI" is an old menu-based UI, which has been replaced |
| by the new one, called "menu UI". |
| """ |
| |
| def trigger_rec_to_dev(self): |
| """ |
| Trigger to-dev transition. |
| """ |
| self.test.switcher.trigger_rec_to_dev() |
| |
| def dev_boot_from_internal(self): |
| """ |
| Boot from internal disk in developer mode. |
| |
| Menu items in developer warning screen: |
| 0. Developer Options |
| 1. Show Debug Info |
| 2. Enable OS Verification |
| *3. Power Off |
| 4. Language |
| |
| Menu items in developer boot options screen: |
| 0. Boot From Network |
| 1. Boot Legacy BIOS |
| 2. Boot From USB or SD Card |
| *3. Boot From Internal Disk |
| 4. Cancel |
| 5. Power Off |
| |
| (*) is the default selection. |
| """ |
| self.test.wait_for('firmware_screen') |
| self.menu.move_to(3, 0) |
| self.menu.select('Selecting "Developer Options"...') |
| self.test.wait_for('keypress_delay') |
| self.menu.select('Selecting "Boot From Internal Disk"...') |
| |
| def dev_boot_from_external(self): |
| """Boot from external disk in developer mode. |
| |
| Menu items in developer warning screen: |
| 0. Developer Options |
| 1. Show Debug Info |
| 2. Enable OS Verification |
| *3. Power Off |
| 4. Language |
| |
| Menu items in developer boot options screen: |
| 0. Boot From Network |
| 1. Boot Legacy BIOS |
| 2. Boot From USB or SD Card |
| *3. Boot From Internal Disk |
| 4. Cancel |
| 5. Power Off |
| 6. Language |
| """ |
| self.test.wait_for('firmware_screen') |
| self.menu.move_to(3, 0) |
| self.menu.select('Selecting "Developer Options"...') |
| self.test.wait_for('keypress_delay') |
| self.menu.move_to(3, 2) |
| self.menu.select('Selecting "Boot From USB or SD Card"...') |
| |
| def trigger_dev_to_normal(self): |
| """ |
| Trigger dev-to-norm transition. |
| |
| Menu items in developer warning screen: |
| 0. Developer Options |
| 1. Show Debug Info |
| 2. Enable OS Verification |
| *3. Power Off |
| 4. Language |
| |
| Menu items in to-norm confirmation screen: |
| *0. Confirm Enabling OS Verification |
| 1. Cancel |
| 2. Power Off |
| 3. Language |
| |
| (*) is the default selection. |
| """ |
| self.test.wait_for('firmware_screen') |
| self.menu.move_to(3, 2) |
| self.menu.select('Selecting "Enable OS Verification"...') |
| self.test.wait_for('keypress_delay') |
| self.menu.select('Selecing "Confirm Enabling OS Verification"...') |
| |
| def power_off(self): |
| """ |
| Power off the device. |
| |
| This method should work in both developer and recovery screens. |
| """ |
| self.test.wait_for('firmware_screen') |
| # Either in developer or recovery screen, the "Power Off" option is the |
| # default one. |
| self.menu.select('Selecting "Power Off"...') |
| |
| |
| class _MenuModeSwitcher(_BaseMenuModeSwitcher): |
| """ |
| Mode switcher with menu navigator for menu UI. |
| |
| The "menu UI" aims to replace both "legacy clamshell UI" and "legacy |
| menu UI". See chromium:1033815 for the discussion about the naming. |
| |
| Menu items in recovery select screen: |
| 0. Language |
| 1. Recovery using phone (always hidden) |
| 2. Recovery using external disk |
| 3. Recovery using internet connection (shown if minios_enabled) |
| 4. Launch diagnostics (shown if minidiag_enabled) |
| 5. Advanced options |
| 6. Power off |
| """ |
| RECOVERY_SELECT_ITEM_COUNT = 7 |
| |
| def _confirm_to_dev(self): |
| if self.faft_config.rec_button_dev_switch: |
| logging.info('Confirm to-dev by RECOVERY button') |
| self.servo.toggle_recovery_switch() |
| elif self.faft_config.power_button_dev_switch: |
| logging.info('Confirm to-dev by POWER button') |
| self.servo.power_normal_press() |
| else: |
| self.menu.select('Confirm to-dev by menu selection') |
| |
| def trigger_rec_to_dev(self): |
| """ |
| Trigger to-dev transition. |
| |
| Menu items in advanced options screen: |
| 0. Language |
| *1. Enable developer mode |
| 2. Back |
| 3. Power off |
| |
| Menu items in to-dev screen: |
| 0. Language |
| *1. Confirm |
| 2. Cancel |
| 3. Power off |
| |
| (*) is the default selection. |
| """ |
| self.test.wait_for('firmware_screen') |
| # The default selection is unknown, navigate to the last item first |
| self.menu.move_to(0, self.RECOVERY_SELECT_ITEM_COUNT) |
| # Navigate to "Advanced options" |
| self.menu.up() |
| self.test.wait_for('keypress_delay') |
| self.menu.select('Selecting "Advanced options"...') |
| self.test.wait_for('keypress_delay') |
| self.menu.select('Selecting "Enable developer mode"...') |
| self.test.wait_for('keypress_delay') |
| # Confirm to-dev transition |
| self._confirm_to_dev() |
| |
| def dev_boot_from_internal(self): |
| """ |
| Boot from internal disk in developer mode. |
| |
| Menu items in developer mode screen: |
| 0. Language |
| 1. Return to secure mode |
| 2. Boot from internal disk |
| 3. Boot from external disk |
| 4. Advanced options |
| 5. Power off |
| """ |
| self.test.wait_for('firmware_screen') |
| # Since the default selection is unknown, navigate to item 0 first |
| self.menu.move_to(5, 0) |
| # Navigate to "Boot from internal disk" |
| self.menu.move_to(0, 2) |
| self.menu.select('Selecting "Boot from internal disk"...') |
| |
| def dev_boot_from_external(self): |
| """Boot from external disk in developer mode. |
| |
| Menu items in developer mode screen: |
| 0. Language |
| 1. Return to secure mode |
| 2. Boot from internal disk |
| 3. Boot from external disk |
| 4. Advanced options |
| 5. Power off |
| """ |
| self.test.wait_for('firmware_screen') |
| # Since the default selection is unknown, navigate to item 0 first |
| self.menu.move_to(5, 0) |
| # Navigate to "Boot from external disk" |
| self.menu.move_to(0, 3) |
| self.menu.select('Selecting "Boot from external disk"...') |
| |
| def trigger_dev_to_normal(self): |
| """ |
| Trigger dev-to-norm transition. |
| |
| Menu items in developer mode screen: |
| 0. Language |
| 1. Return to secure mode |
| 2. Boot from internal disk |
| 3. Boot from external disk |
| 4. Advanced options |
| 5. Power off |
| |
| Menu items in to-norm screen: |
| 0. Language |
| *1. Confirm |
| 2. Cancel |
| 3. Power off |
| |
| (*) is the default selection. |
| """ |
| self.test.wait_for('firmware_screen') |
| # Since the default selection is unknown, navigate to item 0 first |
| self.menu.move_to(5, 0) |
| # Navigate to "Return to secure mode" |
| self.menu.down() |
| self.test.wait_for('keypress_delay') |
| self.menu.select('Selecting "Return to secure mode"...') |
| self.test.wait_for('keypress_delay') |
| self.menu.select('Selecing "Confirm"...') |
| |
| def power_off(self): |
| """ |
| Power off the device. |
| |
| This method should work in both developer and recovery screens. |
| """ |
| self.test.wait_for('firmware_screen') |
| # Since there are at most 6 menu items in dev/rec screen, move the |
| # cursor down 6 times to ensure we reach the last menu item. |
| self.menu.move_to(0, 6) |
| self.menu.select('Selecting "Power off"...') |
| |
| def trigger_rec_to_minidiag(self): |
| """ |
| Trigger rec-to-MiniDiag. |
| |
| @raise TestError if MiniDiag is not enabled. |
| """ |
| |
| # Validity check; this only applicable for MiniDiag enabled devices. |
| if not self.minidiag_enabled: |
| raise error.TestError('MiniDiag is not enabled for this board') |
| |
| self.test.wait_for('firmware_screen') |
| # The default selection is unknown, so navigate to the last item first |
| self.menu.move_to(0, self.RECOVERY_SELECT_ITEM_COUNT) |
| # Navigate to "Launch diagnostics" |
| self.menu.up() |
| self.test.wait_for('keypress_delay') |
| self.menu.up() |
| self.test.wait_for('keypress_delay') |
| self.menu.select('Selecting "Launch diagnostics"...') |
| self.test.wait_for('firmware_screen') |
| |
| def navigate_minidiag_storage(self): |
| """ |
| Navigate to storage screen. |
| |
| Menu items in storage screen: |
| 0. Language |
| 1. Page up (disabled) |
| 2. Page down |
| 3. Back |
| 4. Power off |
| |
| @raise TestError if MiniDiag is not enabled. |
| """ |
| |
| # Validity check; this only applicable for MiniDiag enabled devices. |
| if not self.minidiag_enabled: |
| raise error.TestError('MiniDiag is not enabled for this board') |
| |
| # From root screen to storage screen |
| self.menu.select('Selecting "Storage"...') |
| self.test.wait_for('keypress_delay') |
| # Since the default selection is unknown, navigate to item 4 first |
| self.menu.move_to(0, 4) |
| # Navigate to "Back" |
| self.menu.up() |
| self.test.wait_for('keypress_delay') |
| self.menu.select('Back to MiniDiag root screen...') |
| self.test.wait_for('keypress_delay') |
| |
| def navigate_minidiag_quick_memory_check(self): |
| """ |
| Navigate to quick memory test screen. |
| |
| Menu items in quick memory test screen: |
| 0. Language |
| 1. Page up (disabled) |
| 2. Page down (disabled |
| 3. Back |
| 4. Power off |
| |
| @raise TestError if MiniDiag is not enabled. |
| """ |
| |
| # Validity check; this only applicable for MiniDiag enabled devices. |
| if not self.minidiag_enabled: |
| raise error.TestError('MiniDiag is not enabled for this board') |
| |
| # From root screen to quick memory test screen |
| # There might be self test items, so navigate to the last item first |
| self.menu.move_to(0, 5) |
| self.menu.up() # full memory test |
| self.test.wait_for('keypress_delay') |
| self.menu.up() # quick memory test |
| self.test.wait_for('keypress_delay') |
| self.menu.select('Selecting "Quick memory test"...') |
| self.test.wait_for('keypress_delay') |
| # Wait for quick memory test |
| self.menu.select('Back to MiniDiag root screen...') |
| self.test.wait_for('keypress_delay') |
| |
| def reset_and_leave_minidiag(self): |
| """ |
| Reset the DUT and normal boot to leave MiniDiag. |
| |
| @raise TestError if MiniDiag is not enabled or no apreset support. |
| """ |
| |
| # Validity check; this only applicable for MiniDiag enabled devices. |
| if not self.minidiag_enabled: |
| raise error.TestError('MiniDiag is not enabled for this board') |
| |
| # Since we want to keep the cbmem log, we need an AP reset and reboot to |
| # normal mode |
| if self.test.ec.has_command('apreset'): |
| logging.info('Trigger apreset') |
| self.test.ec.send_command('apreset') |
| else: |
| raise error.TestError('EC command apreset is not supported') |
| |
| def trigger_rec_to_minios(self, older_version=False): |
| """ |
| Trigger recovery-to-MiniOS transition. |
| |
| Menu items in advanced options screen, developer mode: |
| 0. Language |
| *1. Debug info |
| 2. Firmware log |
| 3. Internet recovery (older version) |
| 4. Back |
| 5. Power off |
| |
| (*) is the default selection. |
| |
| @param older_version: True for selecting the older version button in the |
| advanced options screen, and False for selecting |
| the newer one in the recovery selection screen. |
| @raise TestError if MiniOS is not enabled. |
| """ |
| # Validity check |
| if not self.minios_enabled: |
| raise NotImplementedError |
| |
| # Boot to MiniOS through UI menu |
| if older_version: |
| logging.info('Boot to MiniOS (older version)') |
| # The default selection is unknown, so navigate to the last item |
| # first |
| self.menu.move_to(0, self.RECOVERY_SELECT_ITEM_COUNT) |
| # Navigate to "Advanced options" |
| self.menu.up() |
| self.test.wait_for('keypress_delay') |
| self.menu.select('Selecting "Advanced options"...') |
| self.test.wait_for('keypress_delay') |
| # Navigate to the last item in advanced options |
| self.menu.move_to(0, 5) |
| self.menu.move_to(5, 3) |
| self.menu.select( |
| 'Selecting "Internet recovery (older version)"...') |
| else: |
| logging.info('Boot to MiniOS') |
| self.menu.down() |
| self.menu.select( |
| 'Selecting "Recovery using internet connection"...') |
| |
| self.test.wait_for('minios_screen') |
| |
| |
| _MENU_MODE_SWITCHER_CLASSES = { |
| 'menu_switcher': _MenuModeSwitcher, |
| 'tablet_detachable_switcher': _TabletDetachableMenuModeSwitcher, |
| } |
| |
| |
| def create_menu_mode_switcher(faft_framework, menu_navigator): |
| """ |
| Create a proper navigator based on its mode switcher type. |
| |
| @param faft_framework: The main FAFT framework object. |
| @param menu_navigator: The menu navigator for base logic of navigation. |
| """ |
| switcher_type = faft_framework.faft_config.mode_switcher_type |
| switcher_class = _MENU_MODE_SWITCHER_CLASSES.get(switcher_type, None) |
| if switcher_class is None: |
| # Not all devices support menu-based UI, so it is fine to return None. |
| logging.info('Switcher type %s is menuless, return None', |
| switcher_type) |
| return None |
| return switcher_class(faft_framework, menu_navigator) |
