예제 #1
0
  /**
   * Scrolls up and down.
   *
   * @param direction the direction in which to scroll
   * @param allTheWay <code>true</code> if the view should be scrolled to the beginning or end,
   *     <code>false</code> to scroll one page up or down.
   * @return {@code true} if more scrolling can be done
   */
  public boolean scroll(int direction, boolean allTheWay) {
    final ArrayList<View> viewList =
        RobotiumUtils.removeInvisibleViews(viewFetcher.getAllViews(true));
    @SuppressWarnings("unchecked")
    ArrayList<View> views =
        RobotiumUtils.filterViewsToSet(
            new Class[] {ListView.class, ScrollView.class, GridView.class, WebView.class},
            viewList);

    View view = viewFetcher.getFreshestView(views);
    if (view == null) {
      view = viewFetcher.getRecyclerView(0);

      if (view == null) {
        return false;
      }
    }

    if (view instanceof AbsListView) {
      return scrollList((AbsListView) view, direction, allTheWay);
    }

    if (view instanceof WebView) {
      return scrollWebView((WebView) view, direction, allTheWay);
    }

    if (allTheWay) {
      scrollViewAllTheWay(view, direction);
      return false;
    } else {
      return scrollView(view, direction);
    }
  }
예제 #2
0
  /** Extract and wrap the all OpenGL ES Renderer. */
  private void wrapAllGLViews(View decorView) {
    ArrayList<GLSurfaceView> currentViews =
        viewFetcher.getCurrentViews(GLSurfaceView.class, true, decorView);
    final CountDownLatch latch = new CountDownLatch(currentViews.size());

    for (GLSurfaceView glView : currentViews) {
      Object renderContainer =
          new Reflect(glView).field("mGLThread").type(GLSurfaceView.class).out(Object.class);

      Renderer renderer = new Reflect(renderContainer).field("mRenderer").out(Renderer.class);

      if (renderer == null) {
        renderer = new Reflect(glView).field("mRenderer").out(Renderer.class);
        renderContainer = glView;
      }
      if (renderer == null) {
        latch.countDown();
        continue;
      }
      if (renderer instanceof GLRenderWrapper) {
        GLRenderWrapper wrapper = (GLRenderWrapper) renderer;
        wrapper.setTakeScreenshot();
        wrapper.setLatch(latch);
      } else {
        GLRenderWrapper wrapper = new GLRenderWrapper(glView, renderer, latch);
        new Reflect(renderContainer).field("mRenderer").in(wrapper);
      }
    }

    try {
      latch.await();
    } catch (InterruptedException ex) {
      ex.printStackTrace();
    }
  }
예제 #3
0
  /**
   * Waits for and returns a View.
   *
   * @param index the index of the view
   * @param classToFilterby the class to filter
   * @return the specified View
   */
  public <T extends View> T waitForAndGetView(int index, Class<T> classToFilterBy) {
    long endTime = SystemClock.uptimeMillis() + Timeout.getSmallTimeout();
    while (SystemClock.uptimeMillis() <= endTime
        && !waitForView(classToFilterBy, index, true, true)) ;
    int numberOfUniqueViews = searcher.getNumberOfUniqueViews();
    ArrayList<T> views =
        RobotiumUtils.removeInvisibleViews(viewFetcher.getCurrentViews(classToFilterBy));

    if (views.size() < numberOfUniqueViews) {
      int newIndex = index - (numberOfUniqueViews - views.size());
      if (newIndex >= 0) index = newIndex;
    }

    T view = null;
    try {
      view = views.get(index);
    } catch (IndexOutOfBoundsException exception) {
      int match = index + 1;
      if (match > 1) {
        Assert.fail(match + " " + classToFilterBy.getSimpleName() + "s" + " are not found!");
      } else {
        Assert.fail(classToFilterBy.getSimpleName() + " is not found!");
      }
    }
    views = null;
    return view;
  }
예제 #4
0
  /**
   * Waits for a given view.
   *
   * @param view the view to wait for
   * @param timeout the amount of time in milliseconds to wait
   * @param scroll {@code true} if scrolling should be performed
   * @param checkIsShown {@code true} if view.isShown() should be used
   * @return {@code true} if view is shown and {@code false} if it is not shown before the timeout
   */
  public View waitForView(View view, int timeout, boolean scroll, boolean checkIsShown) {
    long endTime = SystemClock.uptimeMillis() + timeout;
    int retry = 0;

    if (view == null) return null;

    while (SystemClock.uptimeMillis() < endTime) {

      final boolean foundAnyMatchingView = searcher.searchFor(view);

      if (checkIsShown && foundAnyMatchingView && !view.isShown()) {
        sleeper.sleepMini();
        retry++;

        View identicalView = viewFetcher.getIdenticalView(view);
        if (identicalView != null && !view.equals(identicalView)) {
          view = identicalView;
        }

        if (retry > 5) {
          return view;
        }
        continue;
      }

      if (foundAnyMatchingView) {
        return view;
      }

      if (scroll) scroller.scrollDown();

      sleeper.sleep();
    }
    return view;
  }
예제 #5
0
 /**
  * Checks if a given text is selected in any {@link Spinner} located on the current screen.
  *
  * @param text the text that is expected to be selected
  * @return {@code true} if the given text is selected in any {@code Spinner} and false if it is
  *     not
  */
 public boolean isSpinnerTextSelected(String text) {
   waiter.waitForView(Spinner.class, 0);
   ArrayList<Spinner> spinnerList = viewFetcher.getCurrentViews(Spinner.class);
   for (int i = 0; i < spinnerList.size(); i++) {
     if (isSpinnerTextSelected(i, text)) return true;
   }
   return false;
 }
예제 #6
0
 /**
  * Checks if a {@link CheckedTextView} with a given text is checked.
  *
  * @param checkedTextView the {@code CheckedTextView} object
  * @param text the text that is expected to be checked
  * @return {@code true} if {@code CheckedTextView} is checked and {@code false} if it is not
  *     checked
  */
 public boolean isCheckedTextChecked(String text) {
   waiter.waitForText(text, 0, 10000, true, true);
   ArrayList<CheckedTextView> list = viewFetcher.getCurrentViews(CheckedTextView.class);
   for (CheckedTextView checkedText : list) {
     if (checkedText.getText().equals(text) && checkedText.isChecked()) return true;
   }
   return false;
 }
예제 #7
0
 /**
  * Checks if a {@link CompoundButton} with a given text is checked.
  *
  * @param expectedClass the expected class, e.g. {@code CheckBox.class} or {@code
  *     RadioButton.class}
  * @param text the text that is expected to be checked
  * @return {@code true} if {@code CompoundButton} is checked and {@code false} if it is not
  *     checked
  */
 public <T extends CompoundButton> boolean isButtonChecked(Class<T> expectedClass, String text) {
   waiter.waitForView(expectedClass, 0);
   ArrayList<T> list = viewFetcher.getCurrentViews(expectedClass);
   for (T button : list) {
     if (button.getText().equals(text) && button.isChecked()) return true;
   }
   return false;
 }
예제 #8
0
  /** Gets the proper view to use for a screenshot. */
  private View getScreenshotView() {
    View decorView = viewFetcher.getRecentDecorView(viewFetcher.getWindowDecorViews());
    final long endTime = SystemClock.uptimeMillis() + Timeout.getSmallTimeout();

    while (decorView == null) {

      final boolean timedOut = SystemClock.uptimeMillis() > endTime;

      if (timedOut) {
        return null;
      }
      sleeper.sleepMini();
      decorView = viewFetcher.getRecentDecorView(viewFetcher.getWindowDecorViews());
    }
    wrapAllGLViews(decorView);

    return decorView;
  }
예제 #9
0
 /**
  * Checks if a {@link CompoundButton} with a given index is checked.
  *
  * @param expectedClass the expected class, e.g. {@code CheckBox.class} or {@code
  *     RadioButton.class}
  * @param index of the {@code CompoundButton} to check. {@code 0} if only one is available
  * @return {@code true} if {@code CompoundButton} is checked and {@code false} if it is not
  *     checked
  */
 public <T extends CompoundButton> boolean isButtonChecked(Class<T> expectedClass, int index) {
   waiter.waitForView(expectedClass, index, false);
   ArrayList<T> list = viewFetcher.getCurrentViews(expectedClass);
   list = RobotiumUtils.removeInvisibleViews(list);
   if (index < 0 || index > list.size() - 1)
     Assert.assertTrue(
         "No " + expectedClass.getSimpleName() + " with index " + index + " is found", false);
   return (list.get(index)).isChecked();
 }
예제 #10
0
 /**
  * Checks if a given text is selected in a given {@link Spinner}
  *
  * @param spinnerIndex the index of the spinner to check. 0 if only one spinner is available
  * @param text the text that is expected to be selected
  * @return true if the given text is selected in the given {@code Spinner} and false if it is not
  */
 public boolean isSpinnerTextSelected(int spinnerIndex, String text) {
   waiter.waitForView(Spinner.class, spinnerIndex, false);
   ArrayList<Spinner> spinnerList = viewFetcher.getCurrentViews(Spinner.class);
   if (spinnerList.size() < spinnerIndex + 1)
     Assert.assertTrue("No spinner with index " + spinnerIndex + " is found! ", false);
   Spinner spinner = spinnerList.get(spinnerIndex);
   TextView textView = (TextView) spinner.getChildAt(spinner.getSelectedItemPosition());
   if (textView.getText().equals(text)) return true;
   else return false;
 }
예제 #11
0
  /**
   * Waits for a certain view.
   *
   * @param view the id of the view to wait for
   * @param index the index of the {@link View}. {@code 0} if only one is available
   * @return the specified View
   */
  public View waitForView(int id, int index, int timeout, boolean scroll) {
    Set<View> uniqueViewsMatchingId = new HashSet<View>();
    long endTime = SystemClock.uptimeMillis() + timeout;

    while (SystemClock.uptimeMillis() <= endTime) {
      sleeper.sleep();

      for (View view : viewFetcher.getAllViews(false)) {
        Integer idOfView = Integer.valueOf(view.getId());

        if (idOfView.equals(id)) {
          uniqueViewsMatchingId.add(view);

          if (uniqueViewsMatchingId.size() > index) {
            return view;
          }
        }
      }
      if (scroll) scroller.scrollDown();
    }
    return null;
  }