path: root/system/blueberry/utils/ui_pages/fitbit_companion/other_pages.py

"""Other pages associated with Fitbit Companion App testing."""
import shlex

from typing import List, Optional
from xml.dom import minidom

from blueberry.utils.ui_pages import errors
from blueberry.utils.ui_pages import ui_core
from blueberry.utils.ui_pages import ui_node
from blueberry.utils.ui_pages.fitbit_companion import constants

# Typing hint alias.
NodeList = List[ui_node.UINode]


class LoginInputPage(ui_core.UIPage):
  """Fitbit Companion App's login input page."""

  PAGE_TEXT = 'Forgot password?'
  _NODE_EMAIL_INPUT_TEXT = f'{constants.PKG_NAME_ID}/login_email'
  _NODE_PASSWORD_INPUT_RID = f'{constants.PKG_NAME_ID}/login_password'
  _NODE_LOGIN_BUTTON_RID = f'{constants.PKG_NAME_ID}/login_button'

  def input(self, account: str, password: str) -> ui_core.UIPage:
    """Inputs login credentials.

    Args:
      account: The account is used to login Fitbit App.
      password: The password is used to login Fitbit App.

    Returns:
      The transformed page.
    """
    self.click_node_by_rid(self._NODE_EMAIL_INPUT_TEXT)
    self.ctx.ad.adb.shell(shlex.split(f'input text "{account}"'))
    self.click_node_by_rid(self._NODE_PASSWORD_INPUT_RID)
    self.ctx.ad.adb.shell(shlex.split(f'input text "{password}"'))
    return self.click_node_by_rid(self._NODE_LOGIN_BUTTON_RID)


class GoogleSmartLockSavePage(ui_core.UIPage):
  """Google SmartLock popup to save input credentials."""

  PAGE_TEXT = 'Save password to Google?'
  _NODE_NO_RID = 'android:id/autofill_save_no'
  _NODE_YES_RID = 'android:id/autofill_save_yes'

  def yes(self) -> ui_core.UIPage:
    """Saves the input credentials in Google SmartLock.

    Returns:
      The transformed page.
    """
    return self.click_node_by_rid(self._NODE_YES_RID)

  def no(self) -> ui_core.UIPage:
    """Skips the request to save input credentials.

    Returns:
      The transformed page.
    """
    return self.click_node_by_rid(self._NODE_NO_RID)


class GoogleSmartLockPage(ui_core.UIPage):
  """Google SmartLock popup from login page."""

  PAGE_TEXT = 'Google Smartlock'
  _NODE_YES_TEXT = 'YES'
  _NODE_NO_TEXT = 'NO'

  def yes(self) -> ui_core.UIPage:
    """Logins by GoogleSmartLock.

    Returns:
      The transformed page.
    """
    return self.click_node_by_text(self._NODE_YES_TEXT)

  def no(self) -> ui_core.UIPage:
    """Skips GoogleSmartLock.

    Returns:
      The transformed page.
    """
    return self.click_node_by_text(self._NODE_NO_TEXT)


class LoginPage(ui_core.UIPage):
  """Fitbit Companion App's login page."""

  PAGE_TEXT = 'Log in'

  def login(self,
            account: str,
            password: str,
            allow_google_smartlock: bool = True) -> ui_core.UIPage:
    """Logins the Fitbit Companion App.

    Args:
      account: Login account
      password: Login password
      allow_google_smartlock: True to allow Google SmartLock feature.

    Returns:
      The transformed page.
    """
    self.click_node_by_text(self.PAGE_TEXT)
    self.ctx.expect_pages([GoogleSmartLockPage, LoginInputPage])
    if self.ctx.is_page(GoogleSmartLockPage):
      if allow_google_smartlock:
        return self.ctx.page.yes()
      else:
        self.ctx.page.no()

    self.ctx.expect_page(LoginInputPage)
    return self.ctx.page.input(account, password)


class GooglePlayPage(ui_core.UIPage):
  """Fitbit Companion App's GooglePlay page."""

  _FITBIT_COMPANION_NAME_TEXT = 'Fitbit, Inc.'
  _NODE_RESOURCE_NAME_RID = 'com.android.vending:id/0_resource_name_obfuscated'
  _NODE_UNINSTALL_BUTTON_TEXT = 'Uninstall'
  _NODE_OPEN_BUTTON_TEXT = 'Open'
  _NODE_INSTALL_BUTTON_TEXT = 'Install'

  @classmethod
  def from_xml(cls, ctx: ui_core.Context, ui_xml: minidom.Document,
               clickable_nodes: NodeList,
               enabled_nodes: NodeList,
               all_nodes: NodeList) -> Optional[ui_core.UIPage]:
    """Instantiates page object from XML object.

    Args:
      ctx: Page context object.
      ui_xml: Parsed XML object.
      clickable_nodes: Clickable node list from page.
      enabled_nodes: Enabled node list from page.
      all_nodes: All node from page.

    Returns:
      UI page object iff the given XML object can be parsed.
    """
    for node in enabled_nodes:
      if (node.text == cls._FITBIT_COMPANION_NAME_TEXT and
          node.resource_id == cls._NODE_RESOURCE_NAME_RID):
        return cls(ctx, ui_xml, clickable_nodes, enabled_nodes, all_nodes)

  def open(self) -> ui_core.UIPage:
    """Opens the Fitbit Companion App.

    Returns:
      The transformed page.
    """
    return self.click_node_by_text(self._NODE_OPEN_BUTTON_TEXT)

  def install(self, open_app: bool = True) -> ui_core.UIPage:
    """Installs the Fitbit Companion App.

    Args:
      open_app: True to open application after installation.

    Returns:
      The transformed page.
    """
    if self.get_node_by_text(self._NODE_OPEN_BUTTON_TEXT) is None:
      # The app is not installed yet.
      self.click_node_by_text(self._NODE_INSTALL_BUTTON_TEXT)
      self.ctx.expect_page(
          self.__class__,
          wait_sec=120,
          node_eval=lambda node: node.text == self._NODE_OPEN_BUTTON_TEXT)

    if open_app:
      return self.ctx.page.open()
    else:
      return self.ctx.page


class AllowLocationPermissionConfirmPopup(ui_core.UIPage):
  """Page to confirm the location permission request."""

  PAGE_RE_TEXT = 'This app wants to access your location'
  _ALLOW_BUTTON_RESOURCE_ID = 'com.android.permissioncontroller:id/permission_no_upgrade_button'

  def allow(self) -> ui_core.UIPage:
    """Allows the request."""
    return self.click_node_by_rid(self._ALLOW_BUTTON_RESOURCE_ID)


class AllowLocationPermissionPopup(ui_core.UIPage):
  """Page to allow location permission."""

  PAGE_TEXT = 'While using the app'

  def next(self) -> ui_core.UIPage:
    """Allows the permission."""
    return self.click_node_by_text(self.PAGE_TEXT)


class LocationPermissionSync(ui_core.UIPage):
  """Page to require location permission required by Fitbit Companion App."""

  PAGE_TEXT = 'Location permission required to sync'
  _EXIT_IMAGE_CLASS = 'android.widget.ImageButton'
  _LOCATION_PERMISSION_CHECK_BOX_TEXT = 'Location Permission'
  _UPDATE_BUTTON_TEXT = 'Update Settings'

  def enable(self) -> ui_core.UIPage:
    """Enables location permission to app."""
    self.ctx.enable_registered_page_call = False
    self.click_node_by_text(self._LOCATION_PERMISSION_CHECK_BOX_TEXT)
    self.ctx.get_page()
    self.ctx.expect_page(AllowLocationPermissionPopup)
    self.ctx.page.next()
    self.ctx.expect_page(AllowLocationPermissionConfirmPopup)
    self.ctx.page.allow()
    self.click_node_by_text(self._UPDATE_BUTTON_TEXT)
    self.ctx.enable_registered_page_call = True
    return self.click_node_by_class(self._EXIT_IMAGE_CLASS)


class PurchaseFail(ui_core.UIPage):
  """Fitbit Companion App's page to show failure of purchase."""

  PAGE_TEXT = 'Purchase failed!'
  _NODE_OK_TEXT = 'OK'

  def ok(self) -> ui_core.UIPage:
    """Confirms the failure.

    Returns:
      The transformed page.
    """
    return self.click_node_by_text(self._NODE_OK_TEXT)


class AllowNotification(ui_core.UIPage):
  """Fitbit Companion App's page to allow access of notification."""

  PAGE_TEXT = 'Allow notification access for Fitbit?'
  _NODE_ALLOW_TEXT = 'Allow'
  _NODE_DENY_TEXT = 'Deny'

  def allow(self) -> ui_core.UIPage:
    """Allows the request.

    Returns:
      The transformed page.
    """
    return self.click_node_by_text(self._NODE_ALLOW_TEXT)

  def deny(self) -> ui_core.UIPage:
    """Denies the request.

    Returns:
      The transformed page.
    """
    return self.click_node_by_text(self._NODE_DENY_TEXT)


class SettingLocation(ui_core.UIPage):
  """Android location setting page."""

  _NODE_SWITCH_RID = 'com.android.settings:id/switch_widget'
  _NODE_SWITCH_TEXT_RID = 'com.android.settings:id/switch_text'

  @classmethod
  def from_xml(cls, ctx: ui_core.Context, ui_xml: minidom.Document,
               clickable_nodes: NodeList,
               enabled_nodes: NodeList,
               all_nodes: NodeList) -> Optional[ui_core.UIPage]:
    """Instantiates page object from XML object.

    Args:
      ctx: Page context object.
      ui_xml: Parsed XML object.
      clickable_nodes: Clickable node list from page.
      enabled_nodes: Enabled node list from page.
      all_nodes: All node from page.

    Returns:
      UI page object iff the given XML object can be parsed.
    """
    for node in enabled_nodes:
      if (node.text == 'Use location' and
          node.resource_id == cls._NODE_SWITCH_TEXT_RID):
        return cls(ctx, ui_xml, clickable_nodes, enabled_nodes, all_nodes)

  def back(self) -> ui_core.UIPage:
    """Backs to previous page.

    Returns:
      The transformed page.
    """
    self.click_node_by_content_desc('Navigate up')
    return self.swipe_left()

  @property
  def enabled(self) -> bool:
    """Checks the location setting.

    Returns:
      True iff the location is enabled.

    Raises:
      errors.UIError: Fail to find the target node.
    """
    node = self.get_node_by_rid(self._NODE_SWITCH_RID)
    if not node:
      raise errors.UIError('Fail to get switch node!')

    return node.attributes['checked'].value == 'true'

  def set(self, value: bool) -> ui_core.UIPage:
    """Toggles the switch to enable/disable location.

    Args:
      value: True to turn on setting; False to turn off setting.

    Returns:
      The transformed page.
    """
    if value != self.enabled:
      return self.click_node_by_rid(self._NODE_SWITCH_RID)

    return self


class LocationDisabledPage(ui_core.UIPage):
  """Popup page for notification as location is disabled."""

  PAGE_RE_TEXT = 'ENABLE LOCATIONS'
  _NODE_ENABLE_TEXT = 'ENABLE LOCATIONS'

  def enable(self) -> ui_core.UIPage:
    """Enables the location setting.

    Returns:
      The transformed page.
    """
    return self.click_node_by_text(self._NODE_ENABLE_TEXT)


class LinkConfirmPage(ui_core.UIPage):
  """Popup page to confirm the process of pairing."""

  PAGE_RID = 'com.android.companiondevicemanager:id/buttons'
  _NODE_PAIR_BTN_RID = 'com.android.companiondevicemanager:id/button_pair'

  def ok(self) -> ui_core.UIPage:
    """Confirms pairing process.

    Returns:
      The transformed page.
    """
    return self.click_node_by_rid(self._NODE_PAIR_BTN_RID)