Java Code Examples for androidx.core.view.ViewCompat#isLaidOut()

/**
 * Shows the tab switcher in an animated manner.
 *
 * @param referenceTabIndex
 *         The index of the tab, which is used as a reference, when restoring the positions of
 *         tabs, as an {@link Integer} value or -1, if the positions of tabs should not be
 *         restored
 * @param referenceTabPosition
 *         The position of tab, which is used as a reference, when restoring the positions of
 *         tabs, in relation to the available space as a {@link Float} value or -1, if the
 *         positions of tabs should not be restored
 */
private void animateShowSwitcher(final int referenceTabIndex,
                                 final float referenceTabPosition) {
    AbstractItem[] items = calculateInitialItems(referenceTabIndex, referenceTabPosition);
    AbstractItemIterator iterator = new InitialItemIteratorBuilder(items).create();
    AbstractItem item;

    while ((item = iterator.next()) != null) {
        if (((TabItem) item).getTab() == getModel().getSelectedTab() || item.isVisible()) {
            tabViewRecycler.inflate(item);
            View view = item.getView();

            if (!ViewCompat.isLaidOut(view)) {
                view.getViewTreeObserver().addOnGlobalLayoutListener(
                        new LayoutListenerWrapper(view,
                                createShowSwitcherLayoutListener(item)));
            } else {
                animateShowSwitcher(item, createUpdateViewAnimationListener(item));
            }
        }
    }

    animateToolbarVisibility(getModel().areToolbarsShown(), toolbarVisibilityAnimationDelay);
}
 

private void animateToTab(int newPosition) {
    if (newPosition == Tab.INVALID_POSITION) {
        return;
    }

    if (getWindowToken() == null || !ViewCompat.isLaidOut(this)
            || mTabStrip.childrenNeedLayout()) {
        // If we don't have a window token, or we haven't been laid out yet just draw the new
        // position now
        setScrollPosition(newPosition, 0f, true);
        return;
    }

    final int startScrollX = getScrollX();
    final int targetScrollX = calculateScrollXForTab(newPosition, 0);

    if (startScrollX != targetScrollX) {
        ensureScrollAnimator();

        mScrollAnimator.setIntValues(startScrollX, targetScrollX);
        mScrollAnimator.start();
    }

    // Now animate the indicator
    mTabStrip.animateIndicatorToPosition(newPosition, ANIMATION_DURATION);
}
 

protected void adjustTabMode(int prevScrollX) {
    if (mAdjustTabModeRunnable != null) {
        return;
    }

    if (prevScrollX < 0) {
        prevScrollX = mTabLayout.getScrollX();
    }

    if (ViewCompat.isLaidOut(mTabLayout)) {
        adjustTabModeInternal(mTabLayout, prevScrollX);
    } else {
        final int prevScrollX1 = prevScrollX;
        mAdjustTabModeRunnable = new Runnable() {
            @Override
            public void run() {
                mAdjustTabModeRunnable = null;
                adjustTabModeInternal(mTabLayout, prevScrollX1);
            }
        };
        mTabLayout.post(mAdjustTabModeRunnable);
    }
}
 

@Override
public final void onScrolled(final RecyclerView recyclerView, final int dx, final int dy) {
    if (ViewCompat.isLaidOut(animatedView)) {
        boolean isScrollingUp = dy < 0;

        if (this.scrollingUp == null || this.scrollingUp != isScrollingUp) {
            this.scrollingUp = isScrollingUp;

            if (scrollingUp) {
                onScrollingUp();
                notifyOnScrollingUp(animatedView, dy);
            } else {
                onScrollingDown();
                notifyOnScrollingDown(animatedView, dy);
            }
        }
    }
}
 

private void hide(boolean animated) {
    if (showing) {
        showing = false;

        if (visibleBulletin == this) {
            visibleBulletin = null;
        }

        if (ViewCompat.isLaidOut(layout)) {
            if (exitRunnable != null) {
                layout.removeCallbacks(exitRunnable);
                exitRunnable = null;
            }
            if (animated) {
                final OffsetProvider offsetProvider = offsetProviders.get(containerLayout);
                layoutTransition.animateExit(layout, layout::onExitTransitionStart, () -> {
                    layout.onExitTransitionEnd();
                    layout.onHide();
                    if (containerLayout != null) {
                        containerLayout.removeView(layout);
                    }
                    layout.onDetach();
                }, offsetProvider != null ? offsetProvider.getBottomOffset() : 0);
                return;
            }
        }

        layout.onExitTransitionStart();
        layout.onExitTransitionEnd();
        layout.onHide();
        if (containerLayout != null) {
            containerLayout.removeView(layout);
        }
        layout.onDetach();
    }
}
 

private void hideScrims() {
  if (scrimsVisible) {
    if (ViewCompat.isLaidOut(this) && !isInEditMode()) {
      animateScrim(0);
    } else {
      setScrimAlpha(0);
    }
    scrimsVisible = false;
  }
}
 

private void showScrims() {
  if (!scrimsVisible) {
    if (ViewCompat.isLaidOut(this) && !isInEditMode()) {
      animateScrim(255);
    } else {
      setScrimAlpha(255);
    }

    scrimsVisible = true;
  }
}
 

private void hide(boolean animated) {
    if (showing) {
        showing = false;

        if (visibleBulletin == this) {
            visibleBulletin = null;
        }

        if (ViewCompat.isLaidOut(layout)) {
            if (exitRunnable != null) {
                layout.removeCallbacks(exitRunnable);
                exitRunnable = null;
            }
            if (animated) {
                final OffsetProvider offsetProvider = offsetProviders.get(containerLayout);
                layoutTransition.animateExit(layout, layout::onExitTransitionStart, () -> {
                    layout.onExitTransitionEnd();
                    layout.onHide();
                    if (containerLayout != null) {
                        containerLayout.removeView(layout);
                    }
                    layout.onDetach();
                }, offsetProvider != null ? offsetProvider.getBottomOffset() : 0);
                return;
            }
        }

        layout.onExitTransitionStart();
        layout.onExitTransitionEnd();
        layout.onHide();
        if (containerLayout != null) {
            containerLayout.removeView(layout);
        }
        layout.onDetach();
    }
}
 

protected void replaceInternal(View outView, View inView, boolean animate) {
    if (animate && mFlipperAnimator != null && ViewCompat.isLaidOut(outView)) {
        mFlipperAnimator.animateFlip(outView, inView);
    } else {
        if (mFlipperAnimator != null && mFlipperAnimator.isAnimating()) {
            outView.animate().cancel();
            inView.animate().cancel();
        }
        outView.setVisibility(View.GONE);
        inView.setVisibility(View.VISIBLE);
    }
}
 

public static void whenLaidOut(View view, Runnable action) {
    if (ViewCompat.isLaidOut(view)) {
        action.run();
    } else {
        view.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
            @Override
            public void onGlobalLayout() {
                view.getViewTreeObserver().removeOnGlobalLayoutListener(this);
                action.run();
            }
        });
    }
}
 

@CallSuper
@Override
public boolean onLayoutChild(
    @NonNull CoordinatorLayout parent, @NonNull final View child, int layoutDirection) {
  if (!ViewCompat.isLaidOut(child)) {
    final ExpandableWidget dep = findExpandableWidget(parent, child);
    if (dep != null && didStateChange(dep.isExpanded())) {
      currentState = dep.isExpanded() ? STATE_EXPANDED : STATE_COLLAPSED;
      @State final int expectedState = currentState;
      child
          .getViewTreeObserver()
          .addOnPreDrawListener(
              new OnPreDrawListener() {
                @Override
                public boolean onPreDraw() {
                  child.getViewTreeObserver().removeOnPreDrawListener(this);
                  // Proceed only if the state did not change while we're waiting for pre-draw.
                  if (currentState == expectedState) {
                    onExpandedStateChange((View) dep, child, dep.isExpanded(), false);
                  }
                  return false;
                }
              });
    }
  }

  return false;
}
 

/**
 * Check if the caption view should animate. Only animate the caption view if we're enabled, laid
 * out, and have a different caption message.
 *
 * @param captionView The view that contains text for the caption underneath the text input area
 * @param captionText The text for the caption view
 * @return Whether the view should animate when setting the caption
 */
private boolean shouldAnimateCaptionView(
    @Nullable TextView captionView, @Nullable final CharSequence captionText) {
  return ViewCompat.isLaidOut(textInputView)
      && textInputView.isEnabled()
      && (captionToShow != captionDisplayed
          || captionView == null
          || !TextUtils.equals(captionView.getText(), captionText));
}
 

private void animateToTab(int newPosition) {
  if (newPosition == Tab.INVALID_POSITION) {
    return;
  }

  if (getWindowToken() == null
      || !ViewCompat.isLaidOut(this)
      || slidingTabIndicator.childrenNeedLayout()) {
    // If we don't have a window token, or we haven't been laid out yet just draw the new
    // position now
    setScrollPosition(newPosition, 0f, true);
    return;
  }

  final int startScrollX = getScrollX();
  final int targetScrollX = calculateScrollXForTab(newPosition, 0);

  if (startScrollX != targetScrollX) {
    ensureScrollAnimator();

    scrollAnimator.setIntValues(startScrollX, targetScrollX);
    scrollAnimator.start();
  }

  // Now animate the indicator
  slidingTabIndicator.animateIndicatorToPosition(newPosition, tabIndicatorAnimationDuration);
}
 

@Override
public boolean onLayoutChild(
    @NonNull CoordinatorLayout parent, @NonNull BottomAppBar child, int layoutDirection) {
  viewRef = new WeakReference<>(child);

  View dependentView = child.findDependentView();
  if (dependentView != null && !ViewCompat.isLaidOut(dependentView)) {
    // Set the initial position of the FloatingActionButton with the BottomAppBar vertical
    // offset.
    CoordinatorLayout.LayoutParams fabLayoutParams =
        (CoordinatorLayout.LayoutParams) dependentView.getLayoutParams();
    fabLayoutParams.anchorGravity = Gravity.CENTER | Gravity.TOP;

    // Keep track of the original bottom margin for the fab. We will manage the margin if
    // nothing was set.
    originalBottomMargin = fabLayoutParams.bottomMargin;

    if (dependentView instanceof FloatingActionButton) {
      FloatingActionButton fab = ((FloatingActionButton) dependentView);

      // Always update the BAB if the fab is laid out.
      fab.addOnLayoutChangeListener(fabLayoutListener);

      // Ensure the FAB is correctly linked to this BAB so the animations can run correctly
      child.addFabAnimationListeners(fab);
    }

    // Move the fab to the correct position
    child.setCutoutState();
  }

  // Now let the CoordinatorLayout lay out the BAB
  parent.onLayoutChild(child, layoutDirection);
  return super.onLayoutChild(parent, child, layoutDirection);
}
 

/**
 * Return in {@code rect} the bounds of the actual floating action button content in view-local
 * coordinates. This is defined as anything within any visible shadow.
 *
 * @return true if this view actually has been laid out and has a content rect, else false.
 * @deprecated prefer {@link FloatingActionButton#getMeasuredContentRect} instead, so you don't
 *     need to handle the case where the view isn't laid out.
 */
@Deprecated
public boolean getContentRect(@NonNull Rect rect) {
  if (ViewCompat.isLaidOut(this)) {
    rect.set(0, 0, getWidth(), getHeight());
    offsetRectWithShadow(rect);
    return true;
  } else {
    return false;
  }
}
 

/** Returns whether or not the view has been laid out **/
private static boolean isLaidOut(View view) {
  return ViewCompat.isLaidOut(view) && view.getWidth() > 0 && view.getHeight() > 0;
}
 

private boolean shouldAnimateVisibilityChange() {
  return ViewCompat.isLaidOut(view) && !view.isInEditMode();
}
 

private boolean shouldAnimateVisibilityChange() {
  return ViewCompat.isLaidOut(this) && !isInEditMode();
}