def select_change_icon_layout(self):
     element = Wait(self.marionette).until(
         expected.element_present(*self._change_icon_layout_locator))
     Wait(self.marionette).until(expected.element_displayed(element))
     element.tap()
     self.marionette.switch_to_frame()
     Wait(self.marionette).until(expected.element_displayed(*self._confirm_layout_button_locator))

 def __init__(self, marionette):
     root = marionette.find_element(*self._details_page_locator)
     PageRegion.__init__(self, marionette, root)
     Wait(self.marionette).until(expected.element_displayed(
         self.root_element.find_element(*self._affected_apps_locator)))
     Wait(self.marionette).until(expected.element_displayed(
         self.root_element.find_element(*self._state_toggle_locator)))

 def tap_call_forwarding(self):
     element = self.marionette.find_element(*self._call_forwarding_locator)
     Wait(self.marionette).until(expected.element_displayed(element) and
                                 expected.element_enabled(element))
     element.tap()
     Wait(self.marionette).until(expected.element_displayed(
         *self._call_forwarding_page_locator))

 def _switch_to_correct_layout(self, val):
     if val.isspace() or val in [',', '.']:
         # certain keys are available on every keyboard panel
         pass
     # Alphabetic keys available on the basic page
     elif val.isalpha():
         is_upper_case = self._is_upper_case
         # If the key to press isalpha and the keyboard layout is not, go back to Basic
         if not self._layout_page == 0:
             self._tap_page_switching_key(0)
             Wait(self.marionette).until(lambda m: self._layout_page == 0)
         # If the key to press isupper and the keyboard is not (or vice versa) then press shift
         if not val.isupper() == is_upper_case:
             self._tap(self._upper_case_key)
             Wait(self.marionette).until(lambda m: is_upper_case != self._is_upper_case)
     # Numbers and symbols are in other keyboard panels
     else:
         # If it's not space or alpha then it must be in Alternate or Symbol.
         # It can't be in Basic so let's go into Alternate and then try to find it
         if self._layout_page == 0 and not self._current_input_type == 'number' and not self._current_input_mode == 'numeric':
             self._tap_page_switching_key(1)
             page_0_key_locator = (self._page_switching_key_locator[0], self._page_switching_key_locator[1] % (0))
             Wait(self.marionette).until(expected.element_displayed(*page_0_key_locator))
         # If it is not present here then it must be in the other non-Basic page
         # (since we must be in either Alternate or Symbol at this stage)
         if not self.is_element_present(*self._key_locator(val)):
             if self._layout_page == 1:
                 self._tap_page_switching_key(2)
                 page_1_key_locator = (self._page_switching_key_locator[0], self._page_switching_key_locator[1] % (1))
                 Wait(self.marionette).until(expected.element_displayed(*page_1_key_locator))
             else:
                 self._tap_page_switching_key(1)
                 page_2_key_locator = (self._page_switching_key_locator[0], self._page_switching_key_locator[1] % (2))
                 Wait(self.marionette).until(expected.element_displayed(*page_2_key_locator))

 def tap_confirm_delay(self):
     element = Wait(self.marionette).until(
         expected.element_present(*self._confirm_delay_change_locator))
     Wait(self.marionette).until(expected.element_displayed(element))
     element.tap()
     self.apps.switch_to_displayed_app()
     Wait(self.marionette).until(expected.element_displayed(*self._delay_locator))

 def tap_auto_retrieve_selector(self):
     element = self.marionette.find_element(*self._auto_retrieve_selector_locator)
     Wait(self.marionette).until(expected.element_displayed(element))
     element.tap()
     self.marionette.switch_to_frame()
     Wait(self.marionette).until(expected.element_displayed(
         *self._auto_retrieve_ok_button_locator))

 def confirm_apn_selection(self):
     element = self.marionette.find_element(*self._apn_selector_confirm_button_locator)
     Wait(self.marionette).until(expected.element_displayed(element) and
                                 expected.element_enabled(element))
     element.tap()
     self.apps.switch_to_displayed_app()
     Wait(self.marionette).until(expected.element_displayed(*self._apn_editor_page_locator))

    def search(self, term):
        iframe = Wait(self.marionette).until(
            expected.element_present(*self._marketplace_iframe_locator))
        Wait(self.marionette).until(expected.element_displayed(iframe))
        self.marionette.switch_to_frame(iframe)

        # This sleep seems necessary, otherwise on device we get timeout failure on display search_box sometimes, see bug 1136791
        import time
        time.sleep(10)

        search_toggle = Wait(self.marionette).until(
            expected.element_present(*self._search_toggle_locator))
        Wait(self.marionette).until(expected.element_displayed(search_toggle))
        search_toggle.tap()

        search_box = Wait(self.marionette).until(
            expected.element_present(*self._search_locator))
        Wait(self.marionette).until(expected.element_displayed(search_box))

        # This sleep is necessary, otherwise the search results are not shown on desktop b2g
        import time
        time.sleep(0.5)

        # search for the app
        search_box.send_keys(term)
        search_box.send_keys(Keys.RETURN)
        return SearchResults(self.marionette)

 def enable_roaming(self):
     element = Wait(self.marionette).until(
         expected.element_present(*self._data_roaming_enabled_label_locator))
     Wait(self.marionette).until(expected.element_displayed(element))
     Wait(self.marionette).until(expected.element_displayed(element) and expected.element_enabled(element))
     element.tap()
     return self.data_prompt

 def tap_auth_numbers(self):
     element = self.marionette.find_element(*self._auth_number_locator)
     Wait(self.marionette).until(expected.element_displayed(element) and
                                 expected.element_enabled(element))
     element.tap()
     Wait(self.marionette).until(expected.element_displayed(
         *self._auth_number_page_locator))

 def tap_sim_1(self):
     element = self.marionette.find_element(*self._sim_1_locator)
     Wait(self.marionette).until(expected.element_displayed(element) and
                                 expected.element_enabled(element))
     element.tap()
     Wait(self.marionette).until(expected.element_displayed(
         *self._call_settings_page_locator))

 def tap_fixed_dialing(self):
     element = self.marionette.find_element(*self._fixed_dialing_numbers_locator)
     Wait(self.marionette).until(expected.element_displayed(element) and
                                 expected.element_enabled(element))
     element.tap()
     Wait(self.marionette).until(expected.element_displayed(
         *self._fixed_dialing_page_locator))

 def open_get_more_home_screen(self):
     element = Wait(self.marionette).until(
         expected.element_present(*self._get_more_homescreen_locator))
     Wait(self.marionette).until(expected.element_displayed(element))
     element.tap()
     self.marionette.switch_to_frame()
     Wait(self.marionette).until(expected.element_displayed(*self._pick_cancel_button_locator))

 def confirm_network_type(self):
     element = self.marionette.find_element(*self._network_type_confirm_button_locator)
     Wait(self.marionette).until(expected.element_displayed(element) and
                                 expected.element_enabled(element))
     element.tap()
     self.apps.switch_to_displayed_app()
     Wait(self.marionette).until(expected.element_displayed(*self._network_type_selector_locator))

    def tap_sim_1(self):
        element = self.marionette.find_element(*self._sim_1_locator)
        Wait(self.marionette).until(expected.element_displayed(element) and expected.element_enabled(element))
        element.tap()
        Wait(self.marionette).until(expected.element_displayed(*self._call_settings_page_locator))

        menu_item = self.marionette.find_element(*self._caller_id_menu_item_locator)
        Wait(self.marionette, timeout=120).until(lambda m: not menu_item.get_attribute("aria-disabled"))

 def tap_change_passcode(self):
     element = self.marionette.find_element(*self._change_passcode_locator)
     Wait(self.marionette).until(expected.element_displayed(element) and expected.element_enabled(element))
     element.tap()
     Wait(self.marionette).until(expected.element_displayed(*self._passcode_page_locator))
     self.marionette.switch_to_frame()
     Wait(self.marionette).until(lambda m: self.keyboard.is_keyboard_displayed)
     self.apps.switch_to_displayed_app()

 def tap_call_barring_all(self):
     element = self.marionette.find_element(*self._call_barring_all_switch_locator)
     Wait(self.marionette).until(expected.element_displayed(element) and expected.element_enabled(element))
     element.tap()
     Wait(self.marionette).until(expected.element_displayed(*self._call_barring_all_cancel_button_locator))
     self.marionette.switch_to_frame()
     Wait(self.marionette).until(lambda m: self.keyboard.is_keyboard_displayed)
     self.apps.switch_to_displayed_app()

 def tap_forward_unanswered(self):
     element = self.marionette.find_element(*self._call_forwarding_unanswered_locator)
     Wait(self.marionette).until(expected.element_displayed(element) and expected.element_enabled(element))
     element.tap()
     Wait(self.marionette).until(expected.element_displayed(*self._call_forwarding_unanswered_page_locator))
     self.marionette.switch_to_frame()
     Wait(self.marionette).until(lambda m: self.keyboard.is_keyboard_displayed)
     self.apps.switch_to_displayed_app()

 def tap_voicemail(self):
     element = self.marionette.find_element(*self._voicemail_locator)
     Wait(self.marionette).until(expected.element_displayed(element) and expected.element_enabled(element))
     element.tap()
     Wait(self.marionette).until(expected.element_displayed(*self._voicemail_number_locator))
     self.marionette.switch_to_frame()
     Wait(self.marionette).until(lambda m: self.keyboard.is_keyboard_displayed)
     self.apps.switch_to_displayed_app()

 def select_roaming_protocol(self):
     element = self.marionette.find_element(*self._roaming_protocol_locator)
     Wait(self.marionette).until(expected.element_displayed(element) and
                                 expected.element_enabled(element))
     element.tap()
     self.marionette.switch_to_frame()
     Wait(self.marionette).until(expected.element_displayed(
         *self._apn_selector_confirm_button_locator))