Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 4457e85a authored Sep 18, 2012 by Fabrice Di Meglio

Fix bug #6427629 Clean up layout direction APIs

- canResolveXxx() should be hidden
- resetResolvedXxx() should be hidden
- resolveDrawables(), resolveLayoutDirection(), resolvePadding(), resolveTextAlignment(), resolveTextDirection() should be hidden
- onResolvedXxx() should be merged into one callback
- fix also an issue with setting the layout direction of the drawable in ImageView
- fix also an issue with checking if TextAlignment can be resolved

Change-Id: I1402269ddf8632525f5550f80e5610e1a7b4034d

parent 4e7b551f

api/17.txt

+0 −2

Original line number	Diff line number	Diff line
		@@ -28704,8 +28704,6 @@ package android.widget {
		method protected void onTextChanged(java.lang.CharSequence, int, int, int);
		method public boolean onTextContextMenuItem(int);
		method public void removeTextChangedListener(android.text.TextWatcher);
		method protected void resetResolvedDrawables();
		method protected void resolveDrawables();
		method public void setAllCaps(boolean);
		method public final void setAutoLinkMask(int);
		method public void setCompoundDrawablePadding(int);

api/current.txt

+1 −19

Original line number	Diff line number	Diff line
		@@ -24774,9 +24774,6 @@ package android.view {
		method public void buildDrawingCache(boolean);
		method public void buildLayer();
		method public boolean callOnClick();
		method public boolean canResolveLayoutDirection();
		method public boolean canResolveTextAlignment();
		method public boolean canResolveTextDirection();
		method public boolean canScrollHorizontally(int);
		method public boolean canScrollVertically(int);
		method public void cancelLongPress();
		@@ -24977,7 +24974,6 @@ package android.view {
		method public boolean isHovered();
		method public boolean isInEditMode();
		method public boolean isInTouchMode();
		method protected static boolean isLayoutDirectionRtl(java.util.Locale);
		method public boolean isLayoutRequested();
		method public boolean isLayoutRtl();
		method public boolean isLongClickable();
		@@ -25033,14 +25029,8 @@ package android.view {
		method protected void onOverScrolled(int, int, boolean, boolean);
		method public void onPaddingChanged(int);
		method public void onPopulateAccessibilityEvent(android.view.accessibility.AccessibilityEvent);
		method public void onResolveDrawables(int);
		method public void onResolvedLayoutDirectionChanged();
		method public void onResolvedLayoutDirectionReset();
		method public void onResolvedTextAlignmentChanged();
		method public void onResolvedTextAlignmentReset();
		method public void onResolvedTextDirectionChanged();
		method public void onResolvedTextDirectionReset();
		method protected void onRestoreInstanceState(android.os.Parcelable);
		method public void onRtlPropertiesChanged();
		method protected android.os.Parcelable onSaveInstanceState();
		method public void onScreenStateChanged(int);
		method protected void onScrollChanged(int, int, int, int);
		@@ -25082,16 +25072,8 @@ package android.view {
		method public void requestLayout();
		method public boolean requestRectangleOnScreen(android.graphics.Rect);
		method public boolean requestRectangleOnScreen(android.graphics.Rect, boolean);
		method public void resetResolvedLayoutDirection();
		method public void resetResolvedTextAlignment();
		method public void resetResolvedTextDirection();
		method public void resolveDrawables();
		method public void resolveLayoutDirection();
		method public void resolvePadding();
		method public static int resolveSize(int, int);
		method public static int resolveSizeAndState(int, int, int);
		method public void resolveTextAlignment();
		method public void resolveTextDirection();
		method public void restoreHierarchyState(android.util.SparseArray<android.os.Parcelable>);
		method public void saveHierarchyState(android.util.SparseArray<android.os.Parcelable>);
		method public void scheduleDrawable(android.graphics.drawable.Drawable, java.lang.Runnable, long);

core/java/android/view/View.java

+95 −116

Original line number	Diff line number	Diff line
		@@ -5798,13 +5798,13 @@ public class View implements Drawable.Callback, KeyEvent.Callback,
		if (getLayoutDirection() != layoutDirection) {
		// Reset the current layout direction and the resolved one
		mPrivateFlags2 &= ~PFLAG2_LAYOUT_DIRECTION_MASK;
		resetResolvedLayoutDirection();
		// Reset padding resolution
		mPrivateFlags2 &= ~PFLAG2_PADDING_RESOLVED;
		resetRtlProperties();
		// Set the new layout direction (filtered)
		mPrivateFlags2 \|=
		((layoutDirection << PFLAG2_LAYOUT_DIRECTION_MASK_SHIFT) & PFLAG2_LAYOUT_DIRECTION_MASK);
		resolveRtlProperties();
		// Notify changes
		onRtlPropertiesChanged();
		// ... and ask for a layout pass
		requestLayout();
		}
		@@ -11474,6 +11474,8 @@ public class View implements Drawable.Callback, KeyEvent.Callback,
		jumpDrawablesToCurrentState();

		resolveRtlProperties();
		// Notify changes
		onRtlPropertiesChanged();

		clearAccessibilityFocus();
		if (isFocused()) {
		@@ -11486,17 +11488,28 @@ public class View implements Drawable.Callback, KeyEvent.Callback,
		}
		}

		/**
		* Resolve all RTL related properties
		*/
		void resolveRtlProperties() {
		// Order is important here: LayoutDirection MUST be resolved first...
		resolveLayoutDirection();
		// ... then we can resolve the others properties depending on the resolved LayoutDirection.
		resolvePadding();
		resolveLayoutParams();
		resolveTextDirection();
		resolveTextAlignment();
		resolvePadding();
		resolveLayoutParams();
		resolveDrawables();
		}

		// Reset resolution of all RTL related properties
		void resetRtlProperties() {
		resetResolvedLayoutDirection();
		resetResolvedTextDirection();
		resetResolvedTextAlignment();
		resetResolvedPadding();
		}

		/**
		* @see #onScreenStateChanged(int)
		*/
		@@ -11523,10 +11536,23 @@ public class View implements Drawable.Callback, KeyEvent.Callback,
		return mContext.getApplicationInfo().hasRtlSupport();
		}

		/**
		* Called when any RTL property (layout direction or text direction or text alignment) has
		* been changed.
		*
		* Subclasses need to override this method to take care of cached information that depends on the
		* resolved layout direction, or to inform child views that inherit their layout direction.
		*
		* The default implementation does nothing.
		*/
		public void onRtlPropertiesChanged() {
		}

		/**
		* Resolve and cache the layout direction. LTR is set initially. This is implicitly supposing
		* that the parent directionality can and will be resolved before its children.
		* Will call {@link View#onResolvedLayoutDirectionChanged} when resolution is done.
		*
		* @hide
		*/
		public void resolveLayoutDirection() {
		// Clear any previous layout direction resolution
		@@ -11554,7 +11580,8 @@ public class View implements Drawable.Callback, KeyEvent.Callback,
		mPrivateFlags2 \|= PFLAG2_LAYOUT_DIRECTION_RESOLVED_RTL;
		break;
		case LAYOUT_DIRECTION_LOCALE:
		if(isLayoutDirectionRtl(Locale.getDefault())) {
		if((LAYOUT_DIRECTION_RTL ==
		TextUtils.getLayoutDirectionFromLocale(Locale.getDefault()))) {
		mPrivateFlags2 \|= PFLAG2_LAYOUT_DIRECTION_RESOLVED_RTL;
		}
		break;
		@@ -11565,19 +11592,38 @@ public class View implements Drawable.Callback, KeyEvent.Callback,

		// Set to resolved
		mPrivateFlags2 \|= PFLAG2_LAYOUT_DIRECTION_RESOLVED;
		onResolvedLayoutDirectionChanged();
		}

		/**
		* Called when layout direction has been resolved.
		* Check if layout direction resolution can be done.
		*
		* The default implementation does nothing.
		* @return true if layout direction resolution can be done otherwise return false.
		*
		* @hide
		*/
		public boolean canResolveLayoutDirection() {
		switch (getLayoutDirection()) {
		case LAYOUT_DIRECTION_INHERIT:
		return (mParent != null) && (mParent instanceof ViewGroup);
		default:
		return true;
		}
		}

		/**
		* Reset the resolved layout direction.
		*
		* @hide
		*/
		public void onResolvedLayoutDirectionChanged() {
		public void resetResolvedLayoutDirection() {
		// Reset the current resolved bits
		mPrivateFlags2 &= ~PFLAG2_LAYOUT_DIRECTION_RESOLVED_MASK;
		}

		/**
		* Return if padding has been resolved
		*
		* @hide
		*/
		boolean isPaddingResolved() {
		return (mPrivateFlags2 & PFLAG2_PADDING_RESOLVED) != 0;
		@@ -11585,6 +11631,8 @@ public class View implements Drawable.Callback, KeyEvent.Callback,

		/**
		* Resolve padding depending on layout direction.
		*
		* @hide
		*/
		public void resolvePadding() {
		final int targetSdkVersion = getContext().getApplicationInfo().targetSdkVersion;
		@@ -11647,6 +11695,15 @@ public class View implements Drawable.Callback, KeyEvent.Callback,
		mPrivateFlags2 \|= PFLAG2_PADDING_RESOLVED;
		}

		/**
		* Reset the resolved layout direction.
		*
		* @hide
		*/
		public void resetResolvedPadding() {
		mPrivateFlags2 &= ~PFLAG2_PADDING_RESOLVED;
		}

		/**
		* Resolve padding depending on the layout direction. Subclasses that care about
		* padding resolution should override this method. The default implementation does
		@@ -11660,53 +11717,6 @@ public class View implements Drawable.Callback, KeyEvent.Callback,
		public void onPaddingChanged(int layoutDirection) {
		}

		/**
		* Check if layout direction resolution can be done.
		*
		* @return true if layout direction resolution can be done otherwise return false.
		*/
		public boolean canResolveLayoutDirection() {
		switch (getLayoutDirection()) {
		case LAYOUT_DIRECTION_INHERIT:
		return (mParent != null) && (mParent instanceof ViewGroup);
		default:
		return true;
		}
		}

		/**
		* Reset the resolved layout direction. Will call {@link View#onResolvedLayoutDirectionReset}
		* when reset is done.
		*/
		public void resetResolvedLayoutDirection() {
		// Reset the current resolved bits
		mPrivateFlags2 &= ~PFLAG2_LAYOUT_DIRECTION_RESOLVED_MASK;
		onResolvedLayoutDirectionReset();
		// Reset also the text direction
		resetResolvedTextDirection();
		}

		/**
		* Called during reset of resolved layout direction.
		*
		* Subclasses need to override this method to clear cached information that depends on the
		* resolved layout direction, or to inform child views that inherit their layout direction.
		*
		* The default implementation does nothing.
		*/
		public void onResolvedLayoutDirectionReset() {
		}

		/**
		* Check if a Locale uses an RTL script.
		*
		* @param locale Locale to check
		* @return true if the Locale uses an RTL script.
		*/
		protected static boolean isLayoutDirectionRtl(Locale locale) {
		return (LAYOUT_DIRECTION_RTL == TextUtils.getLayoutDirectionFromLocale(locale));
		}

		/**
		* This is called when the view is detached from a window. At this point it
		* no longer has a surface for drawing.
		@@ -11737,10 +11747,9 @@ public class View implements Drawable.Callback, KeyEvent.Callback,

		mCurrentAnimation = null;

		resetResolvedLayoutDirection();
		resetResolvedTextAlignment();
		resetRtlProperties();
		onRtlPropertiesChanged();
		resetAccessibilityStateChanged();
		mPrivateFlags2 &= ~PFLAG2_PADDING_RESOLVED;
		}

		/**
		@@ -14087,6 +14096,8 @@ public class View implements Drawable.Callback, KeyEvent.Callback,
		* that the View directionality can and will be resolved before its Drawables.
		*
		* Will call {@link View#onResolveDrawables} when resolution is done.
		*
		* @hide
		*/
		public void resolveDrawables() {
		if (mBackground != null) {
		@@ -14104,6 +14115,8 @@ public class View implements Drawable.Callback, KeyEvent.Callback,
		*
		* @see #LAYOUT_DIRECTION_LTR
		* @see #LAYOUT_DIRECTION_RTL
		*
		* @hide
		*/
		public void onResolveDrawables(int layoutDirection) {
		}
		@@ -14379,8 +14392,7 @@ public class View implements Drawable.Callback, KeyEvent.Callback,
		}
		background.setLayoutDirection(getResolvedLayoutDirection());
		if (background.getPadding(padding)) {
		// Reset padding resolution
		mPrivateFlags2 &= ~PFLAG2_PADDING_RESOLVED;
		resetResolvedPadding();
		switch (background.getLayoutDirection()) {
		case LAYOUT_DIRECTION_RTL:
		mUserPaddingLeftInitial = padding.right;
		@@ -14481,8 +14493,7 @@ public class View implements Drawable.Callback, KeyEvent.Callback,
		* @param bottom the bottom padding in pixels
		*/
		public void setPadding(int left, int top, int right, int bottom) {
		// Reset padding resolution
		mPrivateFlags2 &= ~PFLAG2_PADDING_RESOLVED;
		resetResolvedPadding();

		mUserPaddingStart = UNDEFINED_PADDING;
		mUserPaddingEnd = UNDEFINED_PADDING;
		@@ -14571,8 +14582,7 @@ public class View implements Drawable.Callback, KeyEvent.Callback,
		* @param bottom the bottom padding in pixels
		*/
		public void setPaddingRelative(int start, int top, int end, int bottom) {
		// Reset padding resolution
		mPrivateFlags2 &= ~PFLAG2_PADDING_RESOLVED;
		resetResolvedPadding();

		mUserPaddingStart = start;
		mUserPaddingEnd = end;
		@@ -16509,6 +16519,8 @@ public class View implements Drawable.Callback, KeyEvent.Callback,
		resetResolvedTextDirection();
		// Set the new text direction
		mPrivateFlags2 \|= ((textDirection << PFLAG2_TEXT_DIRECTION_MASK_SHIFT) & PFLAG2_TEXT_DIRECTION_MASK);
		// Notify change
		onRtlPropertiesChanged();
		// Refresh
		requestLayout();
		invalidate(true);
		@@ -16540,8 +16552,9 @@ public class View implements Drawable.Callback, KeyEvent.Callback,
		}

		/**
		* Resolve the text direction. Will call {@link View#onResolvedTextDirectionChanged} when
		* resolution is done.
		* Resolve the text direction.
		*
		* @hide
		*/
		public void resolveTextDirection() {
		// Reset any previous text direction resolution
		@@ -16594,16 +16607,6 @@ public class View implements Drawable.Callback, KeyEvent.Callback,

		// Set to resolved
		mPrivateFlags2 \|= PFLAG2_TEXT_DIRECTION_RESOLVED;
		onResolvedTextDirectionChanged();
		}

		/**
		* Called when text direction has been resolved. Subclasses that care about text direction
		* resolution should override this method.
		*
		* The default implementation does nothing.
		*/
		public void onResolvedTextDirectionChanged() {
		}

		/**
		@@ -16611,7 +16614,7 @@ public class View implements Drawable.Callback, KeyEvent.Callback,
		*
		* @return true if text direction resolution can be done otherwise return false.
		*/
		public boolean canResolveTextDirection() {
		private boolean canResolveTextDirection() {
		switch (getTextDirection()) {
		case TEXT_DIRECTION_INHERIT:
		return (mParent != null) && (mParent instanceof ViewGroup);
		@@ -16622,20 +16625,12 @@ public class View implements Drawable.Callback, KeyEvent.Callback,

		/**
		* Reset resolved text direction. Text direction can be resolved with a call to
		* getResolvedTextDirection(). Will call {@link View#onResolvedTextDirectionReset} when
		* reset is done.
		* getResolvedTextDirection().
		*
		* @hide
		*/
		public void resetResolvedTextDirection() {
		mPrivateFlags2 &= ~(PFLAG2_TEXT_DIRECTION_RESOLVED \| PFLAG2_TEXT_DIRECTION_RESOLVED_MASK);
		onResolvedTextDirectionReset();
		}

		/**
		* Called when text direction is reset. Subclasses that care about text direction reset should
		* override this method and do a reset of the text direction of their children. The default
		* implementation does nothing.
		*/
		public void onResolvedTextDirectionReset() {
		}

		/**
		@@ -16687,6 +16682,8 @@ public class View implements Drawable.Callback, KeyEvent.Callback,
		resetResolvedTextAlignment();
		// Set the new text alignment
		mPrivateFlags2 \|= ((textAlignment << PFLAG2_TEXT_ALIGNMENT_MASK_SHIFT) & PFLAG2_TEXT_ALIGNMENT_MASK);
		// Notify change
		onRtlPropertiesChanged();
		// Refresh
		requestLayout();
		invalidate(true);
		@@ -16727,8 +16724,9 @@ public class View implements Drawable.Callback, KeyEvent.Callback,
		}

		/**
		* Resolve the text alignment. Will call {@link View#onResolvedTextAlignmentChanged} when
		* resolution is done.
		* Resolve the text alignment.
		*
		* @hide
		*/
		public void resolveTextAlignment() {
		// Reset any previous text alignment resolution
		@@ -16740,7 +16738,7 @@ public class View implements Drawable.Callback, KeyEvent.Callback,
		switch (textAlignment) {
		case TEXT_ALIGNMENT_INHERIT:
		// Check if we can resolve the text alignment
		if (canResolveLayoutDirection() && mParent instanceof View) {
		if (canResolveTextAlignment() && mParent instanceof View) {
		View view = (View) mParent;

		final int parentResolvedTextAlignment = view.getResolvedTextAlignment();
		@@ -16786,7 +16784,6 @@ public class View implements Drawable.Callback, KeyEvent.Callback,

		// Set the resolved
		mPrivateFlags2 \|= PFLAG2_TEXT_ALIGNMENT_RESOLVED;
		onResolvedTextAlignmentChanged();
		}

		/**
		@@ -16794,7 +16791,7 @@ public class View implements Drawable.Callback, KeyEvent.Callback,
		*
		* @return true if text alignment resolution can be done otherwise return false.
		*/
		public boolean canResolveTextAlignment() {
		private boolean canResolveTextAlignment() {
		switch (getTextAlignment()) {
		case TEXT_DIRECTION_INHERIT:
		return (mParent != null);
		@@ -16804,31 +16801,13 @@ public class View implements Drawable.Callback, KeyEvent.Callback,
		}

		/**
		* Called when text alignment has been resolved. Subclasses that care about text alignment
		* resolution should override this method.
		* Reset resolved text alignment.
		*
		* The default implementation does nothing.
		*/
		public void onResolvedTextAlignmentChanged() {
		}

		/**
		* Reset resolved text alignment. Text alignment can be resolved with a call to
		* getResolvedTextAlignment(). Will call {@link View#onResolvedTextAlignmentReset} when
		* reset is done.
		* @hide
		*/
		public void resetResolvedTextAlignment() {
		// Reset any previous text alignment resolution
		mPrivateFlags2 &= ~(PFLAG2_TEXT_ALIGNMENT_RESOLVED \| PFLAG2_TEXT_ALIGNMENT_RESOLVED_MASK);
		onResolvedTextAlignmentReset();
		}

		/**
		* Called when text alignment is reset. Subclasses that care about text alignment reset should
		* override this method and do a reset of the text alignment of their children. The default
		* implementation does nothing.
		*/
		public void onResolvedTextAlignmentReset() {
		}

		/**

core/java/android/view/ViewGroup.java

+7 −20

Original line number	Diff line number	Diff line
		@@ -5257,36 +5257,23 @@ public abstract class ViewGroup extends View implements ViewParent, ViewManager
		}
		}

		/**
		* @hide
		*/
		@Override
		public void onResolvedLayoutDirectionReset() {
		public void resetResolvedLayoutDirection() {
		super.resetResolvedLayoutDirection();

		// Take care of resetting the children resolution too
		final int count = getChildCount();
		int count = getChildCount();
		for (int i = 0; i < count; i++) {
		final View child = getChildAt(i);
		if (child.getLayoutDirection() == LAYOUT_DIRECTION_INHERIT) {
		child.resetResolvedLayoutDirection();
		}
		}
		}

		@Override
		public void onResolvedTextDirectionReset() {
		// Take care of resetting the children resolution too
		final int count = getChildCount();
		for (int i = 0; i < count; i++) {
		final View child = getChildAt(i);
		if (child.getTextDirection() == TEXT_DIRECTION_INHERIT) {
		child.resetResolvedTextDirection();
		}
		}
		}

		@Override
		public void onResolvedTextAlignmentReset() {
		// Take care of resetting the children resolution too
		final int count = getChildCount();
		for (int i = 0; i < count; i++) {
		final View child = getChildAt(i);
		if (child.getTextAlignment() == TEXT_ALIGNMENT_INHERIT) {
		child.resetResolvedTextAlignment();
		}

core/java/android/widget/AbsSeekBar.java

+3 −0

Original line number	Diff line number	Diff line
		@@ -308,6 +308,9 @@ public abstract class AbsSeekBar extends ProgressBar {
		thumb.setBounds(left, topBound, left + thumbWidth, bottomBound);
		}

		/**
		* @hide
		*/
		@Override
		public void onResolveDrawables(int layoutDirection) {
		super.onResolveDrawables(layoutDirection);