1793 lines
71 KiB
Java
1793 lines
71 KiB
Java
package androidx.drawerlayout.widget;
|
|
|
|
import android.R;
|
|
import android.content.Context;
|
|
import android.content.res.TypedArray;
|
|
import android.graphics.Canvas;
|
|
import android.graphics.Matrix;
|
|
import android.graphics.Paint;
|
|
import android.graphics.Rect;
|
|
import android.graphics.drawable.ColorDrawable;
|
|
import android.graphics.drawable.Drawable;
|
|
import android.os.Build;
|
|
import android.os.Parcel;
|
|
import android.os.Parcelable;
|
|
import android.os.SystemClock;
|
|
import android.util.AttributeSet;
|
|
import android.view.KeyEvent;
|
|
import android.view.MotionEvent;
|
|
import android.view.View;
|
|
import android.view.ViewGroup;
|
|
import android.view.WindowInsets;
|
|
import android.view.accessibility.AccessibilityEvent;
|
|
import androidx.constraintlayout.core.widgets.analyzer.BasicMeasure;
|
|
import androidx.core.content.ContextCompat;
|
|
import androidx.core.graphics.drawable.DrawableCompat;
|
|
import androidx.core.view.AccessibilityDelegateCompat;
|
|
import androidx.core.view.GravityCompat;
|
|
import androidx.core.view.ViewCompat;
|
|
import androidx.core.view.accessibility.AccessibilityNodeInfoCompat;
|
|
import androidx.core.view.accessibility.AccessibilityViewCommand;
|
|
import androidx.customview.view.AbsSavedState;
|
|
import androidx.customview.widget.Openable;
|
|
import androidx.customview.widget.ViewDragHelper;
|
|
import com.google.android.material.card.MaterialCardViewHelper;
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
|
|
/* loaded from: classes.dex */
|
|
public class DrawerLayout extends ViewGroup implements Openable {
|
|
private static final String ACCESSIBILITY_CLASS_NAME = "androidx.drawerlayout.widget.DrawerLayout";
|
|
private static final boolean ALLOW_EDGE_LOCK = false;
|
|
static final boolean CAN_HIDE_DESCENDANTS;
|
|
private static final boolean CHILDREN_DISALLOW_INTERCEPT = true;
|
|
private static final int DEFAULT_SCRIM_COLOR = -1728053248;
|
|
public static final int LOCK_MODE_LOCKED_CLOSED = 1;
|
|
public static final int LOCK_MODE_LOCKED_OPEN = 2;
|
|
public static final int LOCK_MODE_UNDEFINED = 3;
|
|
public static final int LOCK_MODE_UNLOCKED = 0;
|
|
private static final int MIN_DRAWER_MARGIN = 64;
|
|
private static final int MIN_FLING_VELOCITY = 400;
|
|
private static final int PEEK_DELAY = 160;
|
|
private static final boolean SET_DRAWER_SHADOW_FROM_ELEVATION;
|
|
public static final int STATE_DRAGGING = 1;
|
|
public static final int STATE_IDLE = 0;
|
|
public static final int STATE_SETTLING = 2;
|
|
private static final String TAG = "DrawerLayout";
|
|
private static final float TOUCH_SLOP_SENSITIVITY = 1.0f;
|
|
private static boolean sEdgeSizeUsingSystemGestureInsets;
|
|
private final AccessibilityViewCommand mActionDismiss;
|
|
private final ChildAccessibilityDelegate mChildAccessibilityDelegate;
|
|
private Rect mChildHitRect;
|
|
private Matrix mChildInvertedMatrix;
|
|
private boolean mChildrenCanceledTouch;
|
|
private boolean mDrawStatusBarBackground;
|
|
private float mDrawerElevation;
|
|
private int mDrawerState;
|
|
private boolean mFirstLayout;
|
|
private boolean mInLayout;
|
|
private float mInitialMotionX;
|
|
private float mInitialMotionY;
|
|
private Object mLastInsets;
|
|
private final ViewDragCallback mLeftCallback;
|
|
private final ViewDragHelper mLeftDragger;
|
|
private DrawerListener mListener;
|
|
private List<DrawerListener> mListeners;
|
|
private int mLockModeEnd;
|
|
private int mLockModeLeft;
|
|
private int mLockModeRight;
|
|
private int mLockModeStart;
|
|
private int mMinDrawerMargin;
|
|
private final ArrayList<View> mNonDrawerViews;
|
|
private final ViewDragCallback mRightCallback;
|
|
private final ViewDragHelper mRightDragger;
|
|
private int mScrimColor;
|
|
private float mScrimOpacity;
|
|
private Paint mScrimPaint;
|
|
private Drawable mShadowEnd;
|
|
private Drawable mShadowLeft;
|
|
private Drawable mShadowLeftResolved;
|
|
private Drawable mShadowRight;
|
|
private Drawable mShadowRightResolved;
|
|
private Drawable mShadowStart;
|
|
private Drawable mStatusBarBackground;
|
|
private CharSequence mTitleLeft;
|
|
private CharSequence mTitleRight;
|
|
private static final int[] THEME_ATTRS = {R.attr.colorPrimaryDark};
|
|
static final int[] LAYOUT_ATTRS = {R.attr.layout_gravity};
|
|
|
|
public interface DrawerListener {
|
|
void onDrawerClosed(View view);
|
|
|
|
void onDrawerOpened(View view);
|
|
|
|
void onDrawerSlide(View view, float f);
|
|
|
|
void onDrawerStateChanged(int i);
|
|
}
|
|
|
|
public static abstract class SimpleDrawerListener implements DrawerListener {
|
|
@Override // androidx.drawerlayout.widget.DrawerLayout.DrawerListener
|
|
public void onDrawerClosed(View view) {
|
|
}
|
|
|
|
@Override // androidx.drawerlayout.widget.DrawerLayout.DrawerListener
|
|
public void onDrawerOpened(View view) {
|
|
}
|
|
|
|
@Override // androidx.drawerlayout.widget.DrawerLayout.DrawerListener
|
|
public void onDrawerSlide(View view, float f) {
|
|
}
|
|
|
|
@Override // androidx.drawerlayout.widget.DrawerLayout.DrawerListener
|
|
public void onDrawerStateChanged(int i) {
|
|
}
|
|
}
|
|
|
|
static {
|
|
boolean z = CHILDREN_DISALLOW_INTERCEPT;
|
|
CAN_HIDE_DESCENDANTS = CHILDREN_DISALLOW_INTERCEPT;
|
|
SET_DRAWER_SHADOW_FROM_ELEVATION = CHILDREN_DISALLOW_INTERCEPT;
|
|
if (Build.VERSION.SDK_INT < 29) {
|
|
z = false;
|
|
}
|
|
sEdgeSizeUsingSystemGestureInsets = z;
|
|
}
|
|
|
|
public float getDrawerElevation() {
|
|
if (SET_DRAWER_SHADOW_FROM_ELEVATION) {
|
|
return this.mDrawerElevation;
|
|
}
|
|
return 0.0f;
|
|
}
|
|
|
|
public Drawable getStatusBarBackgroundDrawable() {
|
|
return this.mStatusBarBackground;
|
|
}
|
|
|
|
public DrawerLayout(Context context) {
|
|
this(context, null);
|
|
}
|
|
|
|
public DrawerLayout(Context context, AttributeSet attributeSet) {
|
|
this(context, attributeSet, androidx.drawerlayout.R.attr.drawerLayoutStyle);
|
|
}
|
|
|
|
public DrawerLayout(Context context, AttributeSet attributeSet, int i) {
|
|
super(context, attributeSet, i);
|
|
this.mChildAccessibilityDelegate = new ChildAccessibilityDelegate();
|
|
this.mScrimColor = DEFAULT_SCRIM_COLOR;
|
|
this.mScrimPaint = new Paint();
|
|
this.mFirstLayout = CHILDREN_DISALLOW_INTERCEPT;
|
|
this.mLockModeLeft = 3;
|
|
this.mLockModeRight = 3;
|
|
this.mLockModeStart = 3;
|
|
this.mLockModeEnd = 3;
|
|
this.mShadowStart = null;
|
|
this.mShadowEnd = null;
|
|
this.mShadowLeft = null;
|
|
this.mShadowRight = null;
|
|
this.mActionDismiss = new AccessibilityViewCommand() { // from class: androidx.drawerlayout.widget.DrawerLayout.1
|
|
@Override // androidx.core.view.accessibility.AccessibilityViewCommand
|
|
public boolean perform(View view, AccessibilityViewCommand.CommandArguments commandArguments) {
|
|
if (!DrawerLayout.this.isDrawerOpen(view) || DrawerLayout.this.getDrawerLockMode(view) == 2) {
|
|
return false;
|
|
}
|
|
DrawerLayout.this.closeDrawer(view);
|
|
return DrawerLayout.CHILDREN_DISALLOW_INTERCEPT;
|
|
}
|
|
};
|
|
setDescendantFocusability(262144);
|
|
float f = getResources().getDisplayMetrics().density;
|
|
this.mMinDrawerMargin = (int) ((64.0f * f) + 0.5f);
|
|
float f2 = f * 400.0f;
|
|
ViewDragCallback viewDragCallback = new ViewDragCallback(3);
|
|
this.mLeftCallback = viewDragCallback;
|
|
ViewDragCallback viewDragCallback2 = new ViewDragCallback(5);
|
|
this.mRightCallback = viewDragCallback2;
|
|
ViewDragHelper create = ViewDragHelper.create(this, 1.0f, viewDragCallback);
|
|
this.mLeftDragger = create;
|
|
create.setEdgeTrackingEnabled(1);
|
|
create.setMinVelocity(f2);
|
|
viewDragCallback.setDragger(create);
|
|
ViewDragHelper create2 = ViewDragHelper.create(this, 1.0f, viewDragCallback2);
|
|
this.mRightDragger = create2;
|
|
create2.setEdgeTrackingEnabled(2);
|
|
create2.setMinVelocity(f2);
|
|
viewDragCallback2.setDragger(create2);
|
|
setFocusableInTouchMode(CHILDREN_DISALLOW_INTERCEPT);
|
|
ViewCompat.setImportantForAccessibility(this, 1);
|
|
ViewCompat.setAccessibilityDelegate(this, new AccessibilityDelegate());
|
|
setMotionEventSplittingEnabled(false);
|
|
if (ViewCompat.getFitsSystemWindows(this)) {
|
|
setOnApplyWindowInsetsListener(new View.OnApplyWindowInsetsListener() { // from class: androidx.drawerlayout.widget.DrawerLayout.2
|
|
@Override // android.view.View.OnApplyWindowInsetsListener
|
|
public WindowInsets onApplyWindowInsets(View view, WindowInsets windowInsets) {
|
|
((DrawerLayout) view).setChildInsets(windowInsets, windowInsets.getSystemWindowInsetTop() > 0 ? DrawerLayout.CHILDREN_DISALLOW_INTERCEPT : false);
|
|
return windowInsets.consumeSystemWindowInsets();
|
|
}
|
|
});
|
|
setSystemUiVisibility(1280);
|
|
TypedArray obtainStyledAttributes = context.obtainStyledAttributes(THEME_ATTRS);
|
|
try {
|
|
this.mStatusBarBackground = obtainStyledAttributes.getDrawable(0);
|
|
} finally {
|
|
obtainStyledAttributes.recycle();
|
|
}
|
|
}
|
|
TypedArray obtainStyledAttributes2 = context.obtainStyledAttributes(attributeSet, androidx.drawerlayout.R.styleable.DrawerLayout, i, 0);
|
|
try {
|
|
if (obtainStyledAttributes2.hasValue(androidx.drawerlayout.R.styleable.DrawerLayout_elevation)) {
|
|
this.mDrawerElevation = obtainStyledAttributes2.getDimension(androidx.drawerlayout.R.styleable.DrawerLayout_elevation, 0.0f);
|
|
} else {
|
|
this.mDrawerElevation = getResources().getDimension(androidx.drawerlayout.R.dimen.def_drawer_elevation);
|
|
}
|
|
obtainStyledAttributes2.recycle();
|
|
this.mNonDrawerViews = new ArrayList<>();
|
|
} catch (Throwable th) {
|
|
obtainStyledAttributes2.recycle();
|
|
throw th;
|
|
}
|
|
}
|
|
|
|
public void setDrawerElevation(float f) {
|
|
this.mDrawerElevation = f;
|
|
for (int i = 0; i < getChildCount(); i++) {
|
|
View childAt = getChildAt(i);
|
|
if (isDrawerView(childAt)) {
|
|
ViewCompat.setElevation(childAt, this.mDrawerElevation);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void setChildInsets(Object obj, boolean z) {
|
|
this.mLastInsets = obj;
|
|
this.mDrawStatusBarBackground = z;
|
|
setWillNotDraw((z || getBackground() != null) ? false : CHILDREN_DISALLOW_INTERCEPT);
|
|
requestLayout();
|
|
}
|
|
|
|
public void setDrawerShadow(Drawable drawable, int i) {
|
|
if (SET_DRAWER_SHADOW_FROM_ELEVATION) {
|
|
return;
|
|
}
|
|
if ((i & GravityCompat.START) == 8388611) {
|
|
this.mShadowStart = drawable;
|
|
} else if ((i & GravityCompat.END) == 8388613) {
|
|
this.mShadowEnd = drawable;
|
|
} else if ((i & 3) == 3) {
|
|
this.mShadowLeft = drawable;
|
|
} else if ((i & 5) != 5) {
|
|
return;
|
|
} else {
|
|
this.mShadowRight = drawable;
|
|
}
|
|
resolveShadowDrawables();
|
|
invalidate();
|
|
}
|
|
|
|
public void setDrawerShadow(int i, int i2) {
|
|
setDrawerShadow(ContextCompat.getDrawable(getContext(), i), i2);
|
|
}
|
|
|
|
public void setScrimColor(int i) {
|
|
this.mScrimColor = i;
|
|
invalidate();
|
|
}
|
|
|
|
@Deprecated
|
|
public void setDrawerListener(DrawerListener drawerListener) {
|
|
DrawerListener drawerListener2 = this.mListener;
|
|
if (drawerListener2 != null) {
|
|
removeDrawerListener(drawerListener2);
|
|
}
|
|
if (drawerListener != null) {
|
|
addDrawerListener(drawerListener);
|
|
}
|
|
this.mListener = drawerListener;
|
|
}
|
|
|
|
public void addDrawerListener(DrawerListener drawerListener) {
|
|
if (drawerListener == null) {
|
|
return;
|
|
}
|
|
if (this.mListeners == null) {
|
|
this.mListeners = new ArrayList();
|
|
}
|
|
this.mListeners.add(drawerListener);
|
|
}
|
|
|
|
public void removeDrawerListener(DrawerListener drawerListener) {
|
|
List<DrawerListener> list;
|
|
if (drawerListener == null || (list = this.mListeners) == null) {
|
|
return;
|
|
}
|
|
list.remove(drawerListener);
|
|
}
|
|
|
|
public void setDrawerLockMode(int i) {
|
|
setDrawerLockMode(i, 3);
|
|
setDrawerLockMode(i, 5);
|
|
}
|
|
|
|
public void setDrawerLockMode(int i, int i2) {
|
|
View findDrawerWithGravity;
|
|
int absoluteGravity = GravityCompat.getAbsoluteGravity(i2, ViewCompat.getLayoutDirection(this));
|
|
if (i2 == 3) {
|
|
this.mLockModeLeft = i;
|
|
} else if (i2 == 5) {
|
|
this.mLockModeRight = i;
|
|
} else if (i2 == 8388611) {
|
|
this.mLockModeStart = i;
|
|
} else if (i2 == 8388613) {
|
|
this.mLockModeEnd = i;
|
|
}
|
|
if (i != 0) {
|
|
(absoluteGravity == 3 ? this.mLeftDragger : this.mRightDragger).cancel();
|
|
}
|
|
if (i != 1) {
|
|
if (i == 2 && (findDrawerWithGravity = findDrawerWithGravity(absoluteGravity)) != null) {
|
|
openDrawer(findDrawerWithGravity);
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
View findDrawerWithGravity2 = findDrawerWithGravity(absoluteGravity);
|
|
if (findDrawerWithGravity2 != null) {
|
|
closeDrawer(findDrawerWithGravity2);
|
|
}
|
|
}
|
|
|
|
public void setDrawerLockMode(int i, View view) {
|
|
if (!isDrawerView(view)) {
|
|
throw new IllegalArgumentException("View " + view + " is not a drawer with appropriate layout_gravity");
|
|
}
|
|
setDrawerLockMode(i, ((LayoutParams) view.getLayoutParams()).gravity);
|
|
}
|
|
|
|
public int getDrawerLockMode(int i) {
|
|
int layoutDirection = ViewCompat.getLayoutDirection(this);
|
|
if (i == 3) {
|
|
int i2 = this.mLockModeLeft;
|
|
if (i2 != 3) {
|
|
return i2;
|
|
}
|
|
int i3 = layoutDirection == 0 ? this.mLockModeStart : this.mLockModeEnd;
|
|
if (i3 != 3) {
|
|
return i3;
|
|
}
|
|
return 0;
|
|
}
|
|
if (i == 5) {
|
|
int i4 = this.mLockModeRight;
|
|
if (i4 != 3) {
|
|
return i4;
|
|
}
|
|
int i5 = layoutDirection == 0 ? this.mLockModeEnd : this.mLockModeStart;
|
|
if (i5 != 3) {
|
|
return i5;
|
|
}
|
|
return 0;
|
|
}
|
|
if (i == 8388611) {
|
|
int i6 = this.mLockModeStart;
|
|
if (i6 != 3) {
|
|
return i6;
|
|
}
|
|
int i7 = layoutDirection == 0 ? this.mLockModeLeft : this.mLockModeRight;
|
|
if (i7 != 3) {
|
|
return i7;
|
|
}
|
|
return 0;
|
|
}
|
|
if (i != 8388613) {
|
|
return 0;
|
|
}
|
|
int i8 = this.mLockModeEnd;
|
|
if (i8 != 3) {
|
|
return i8;
|
|
}
|
|
int i9 = layoutDirection == 0 ? this.mLockModeRight : this.mLockModeLeft;
|
|
if (i9 != 3) {
|
|
return i9;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
public int getDrawerLockMode(View view) {
|
|
if (!isDrawerView(view)) {
|
|
throw new IllegalArgumentException("View " + view + " is not a drawer");
|
|
}
|
|
return getDrawerLockMode(((LayoutParams) view.getLayoutParams()).gravity);
|
|
}
|
|
|
|
public void setDrawerTitle(int i, CharSequence charSequence) {
|
|
int absoluteGravity = GravityCompat.getAbsoluteGravity(i, ViewCompat.getLayoutDirection(this));
|
|
if (absoluteGravity == 3) {
|
|
this.mTitleLeft = charSequence;
|
|
} else if (absoluteGravity == 5) {
|
|
this.mTitleRight = charSequence;
|
|
}
|
|
}
|
|
|
|
public CharSequence getDrawerTitle(int i) {
|
|
int absoluteGravity = GravityCompat.getAbsoluteGravity(i, ViewCompat.getLayoutDirection(this));
|
|
if (absoluteGravity == 3) {
|
|
return this.mTitleLeft;
|
|
}
|
|
if (absoluteGravity == 5) {
|
|
return this.mTitleRight;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private boolean isInBoundsOfChild(float f, float f2, View view) {
|
|
if (this.mChildHitRect == null) {
|
|
this.mChildHitRect = new Rect();
|
|
}
|
|
view.getHitRect(this.mChildHitRect);
|
|
return this.mChildHitRect.contains((int) f, (int) f2);
|
|
}
|
|
|
|
private boolean dispatchTransformedGenericPointerEvent(MotionEvent motionEvent, View view) {
|
|
if (!view.getMatrix().isIdentity()) {
|
|
MotionEvent transformedMotionEvent = getTransformedMotionEvent(motionEvent, view);
|
|
boolean dispatchGenericMotionEvent = view.dispatchGenericMotionEvent(transformedMotionEvent);
|
|
transformedMotionEvent.recycle();
|
|
return dispatchGenericMotionEvent;
|
|
}
|
|
float scrollX = getScrollX() - view.getLeft();
|
|
float scrollY = getScrollY() - view.getTop();
|
|
motionEvent.offsetLocation(scrollX, scrollY);
|
|
boolean dispatchGenericMotionEvent2 = view.dispatchGenericMotionEvent(motionEvent);
|
|
motionEvent.offsetLocation(-scrollX, -scrollY);
|
|
return dispatchGenericMotionEvent2;
|
|
}
|
|
|
|
private MotionEvent getTransformedMotionEvent(MotionEvent motionEvent, View view) {
|
|
float scrollX = getScrollX() - view.getLeft();
|
|
float scrollY = getScrollY() - view.getTop();
|
|
MotionEvent obtain = MotionEvent.obtain(motionEvent);
|
|
obtain.offsetLocation(scrollX, scrollY);
|
|
Matrix matrix = view.getMatrix();
|
|
if (!matrix.isIdentity()) {
|
|
if (this.mChildInvertedMatrix == null) {
|
|
this.mChildInvertedMatrix = new Matrix();
|
|
}
|
|
matrix.invert(this.mChildInvertedMatrix);
|
|
obtain.transform(this.mChildInvertedMatrix);
|
|
}
|
|
return obtain;
|
|
}
|
|
|
|
void updateDrawerState(int i, View view) {
|
|
int i2;
|
|
int viewDragState = this.mLeftDragger.getViewDragState();
|
|
int viewDragState2 = this.mRightDragger.getViewDragState();
|
|
if (viewDragState == 1 || viewDragState2 == 1) {
|
|
i2 = 1;
|
|
} else {
|
|
i2 = 2;
|
|
if (viewDragState != 2 && viewDragState2 != 2) {
|
|
i2 = 0;
|
|
}
|
|
}
|
|
if (view != null && i == 0) {
|
|
LayoutParams layoutParams = (LayoutParams) view.getLayoutParams();
|
|
if (layoutParams.onScreen == 0.0f) {
|
|
dispatchOnDrawerClosed(view);
|
|
} else if (layoutParams.onScreen == 1.0f) {
|
|
dispatchOnDrawerOpened(view);
|
|
}
|
|
}
|
|
if (i2 != this.mDrawerState) {
|
|
this.mDrawerState = i2;
|
|
List<DrawerListener> list = this.mListeners;
|
|
if (list != null) {
|
|
for (int size = list.size() - 1; size >= 0; size--) {
|
|
this.mListeners.get(size).onDrawerStateChanged(i2);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void dispatchOnDrawerClosed(View view) {
|
|
View rootView;
|
|
LayoutParams layoutParams = (LayoutParams) view.getLayoutParams();
|
|
if ((layoutParams.openState & 1) == 1) {
|
|
layoutParams.openState = 0;
|
|
List<DrawerListener> list = this.mListeners;
|
|
if (list != null) {
|
|
for (int size = list.size() - 1; size >= 0; size--) {
|
|
this.mListeners.get(size).onDrawerClosed(view);
|
|
}
|
|
}
|
|
updateChildrenImportantForAccessibility(view, false);
|
|
updateChildAccessibilityAction(view);
|
|
if (!hasWindowFocus() || (rootView = getRootView()) == null) {
|
|
return;
|
|
}
|
|
rootView.sendAccessibilityEvent(32);
|
|
}
|
|
}
|
|
|
|
void dispatchOnDrawerOpened(View view) {
|
|
LayoutParams layoutParams = (LayoutParams) view.getLayoutParams();
|
|
if ((layoutParams.openState & 1) == 0) {
|
|
layoutParams.openState = 1;
|
|
List<DrawerListener> list = this.mListeners;
|
|
if (list != null) {
|
|
for (int size = list.size() - 1; size >= 0; size--) {
|
|
this.mListeners.get(size).onDrawerOpened(view);
|
|
}
|
|
}
|
|
updateChildrenImportantForAccessibility(view, CHILDREN_DISALLOW_INTERCEPT);
|
|
updateChildAccessibilityAction(view);
|
|
if (hasWindowFocus()) {
|
|
sendAccessibilityEvent(32);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void updateChildrenImportantForAccessibility(View view, boolean z) {
|
|
int childCount = getChildCount();
|
|
for (int i = 0; i < childCount; i++) {
|
|
View childAt = getChildAt(i);
|
|
if ((!z && !isDrawerView(childAt)) || (z && childAt == view)) {
|
|
ViewCompat.setImportantForAccessibility(childAt, 1);
|
|
} else {
|
|
ViewCompat.setImportantForAccessibility(childAt, 4);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void updateChildAccessibilityAction(View view) {
|
|
ViewCompat.removeAccessibilityAction(view, AccessibilityNodeInfoCompat.AccessibilityActionCompat.ACTION_DISMISS.getId());
|
|
if (!isDrawerOpen(view) || getDrawerLockMode(view) == 2) {
|
|
return;
|
|
}
|
|
ViewCompat.replaceAccessibilityAction(view, AccessibilityNodeInfoCompat.AccessibilityActionCompat.ACTION_DISMISS, null, this.mActionDismiss);
|
|
}
|
|
|
|
void dispatchOnDrawerSlide(View view, float f) {
|
|
List<DrawerListener> list = this.mListeners;
|
|
if (list != null) {
|
|
for (int size = list.size() - 1; size >= 0; size--) {
|
|
this.mListeners.get(size).onDrawerSlide(view, f);
|
|
}
|
|
}
|
|
}
|
|
|
|
void setDrawerViewOffset(View view, float f) {
|
|
LayoutParams layoutParams = (LayoutParams) view.getLayoutParams();
|
|
if (f == layoutParams.onScreen) {
|
|
return;
|
|
}
|
|
layoutParams.onScreen = f;
|
|
dispatchOnDrawerSlide(view, f);
|
|
}
|
|
|
|
float getDrawerViewOffset(View view) {
|
|
return ((LayoutParams) view.getLayoutParams()).onScreen;
|
|
}
|
|
|
|
int getDrawerViewAbsoluteGravity(View view) {
|
|
return GravityCompat.getAbsoluteGravity(((LayoutParams) view.getLayoutParams()).gravity, ViewCompat.getLayoutDirection(this));
|
|
}
|
|
|
|
boolean checkDrawerViewAbsoluteGravity(View view, int i) {
|
|
if ((getDrawerViewAbsoluteGravity(view) & i) == i) {
|
|
return CHILDREN_DISALLOW_INTERCEPT;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
View findOpenDrawer() {
|
|
int childCount = getChildCount();
|
|
for (int i = 0; i < childCount; i++) {
|
|
View childAt = getChildAt(i);
|
|
if ((((LayoutParams) childAt.getLayoutParams()).openState & 1) == 1) {
|
|
return childAt;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
void moveDrawerToOffset(View view, float f) {
|
|
float drawerViewOffset = getDrawerViewOffset(view);
|
|
float width = view.getWidth();
|
|
int i = ((int) (width * f)) - ((int) (drawerViewOffset * width));
|
|
if (!checkDrawerViewAbsoluteGravity(view, 3)) {
|
|
i = -i;
|
|
}
|
|
view.offsetLeftAndRight(i);
|
|
setDrawerViewOffset(view, f);
|
|
}
|
|
|
|
View findDrawerWithGravity(int i) {
|
|
int absoluteGravity = GravityCompat.getAbsoluteGravity(i, ViewCompat.getLayoutDirection(this)) & 7;
|
|
int childCount = getChildCount();
|
|
for (int i2 = 0; i2 < childCount; i2++) {
|
|
View childAt = getChildAt(i2);
|
|
if ((getDrawerViewAbsoluteGravity(childAt) & 7) == absoluteGravity) {
|
|
return childAt;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
static String gravityToString(int i) {
|
|
return (i & 3) == 3 ? "LEFT" : (i & 5) == 5 ? "RIGHT" : Integer.toHexString(i);
|
|
}
|
|
|
|
@Override // android.view.ViewGroup, android.view.View
|
|
protected void onDetachedFromWindow() {
|
|
super.onDetachedFromWindow();
|
|
this.mFirstLayout = CHILDREN_DISALLOW_INTERCEPT;
|
|
}
|
|
|
|
@Override // android.view.ViewGroup, android.view.View
|
|
protected void onAttachedToWindow() {
|
|
super.onAttachedToWindow();
|
|
this.mFirstLayout = CHILDREN_DISALLOW_INTERCEPT;
|
|
}
|
|
|
|
@Override // android.view.View
|
|
protected void onMeasure(int i, int i2) {
|
|
int mode = View.MeasureSpec.getMode(i);
|
|
int mode2 = View.MeasureSpec.getMode(i2);
|
|
int size = View.MeasureSpec.getSize(i);
|
|
int size2 = View.MeasureSpec.getSize(i2);
|
|
if (mode != 1073741824 || mode2 != 1073741824) {
|
|
if (!isInEditMode()) {
|
|
throw new IllegalArgumentException("DrawerLayout must be measured with MeasureSpec.EXACTLY.");
|
|
}
|
|
if (mode == 0) {
|
|
size = MaterialCardViewHelper.DEFAULT_FADE_ANIM_DURATION;
|
|
}
|
|
if (mode2 == 0) {
|
|
size2 = MaterialCardViewHelper.DEFAULT_FADE_ANIM_DURATION;
|
|
}
|
|
}
|
|
setMeasuredDimension(size, size2);
|
|
boolean z = (this.mLastInsets == null || !ViewCompat.getFitsSystemWindows(this)) ? false : CHILDREN_DISALLOW_INTERCEPT;
|
|
int layoutDirection = ViewCompat.getLayoutDirection(this);
|
|
int childCount = getChildCount();
|
|
boolean z2 = false;
|
|
boolean z3 = false;
|
|
for (int i3 = 0; i3 < childCount; i3++) {
|
|
View childAt = getChildAt(i3);
|
|
if (childAt.getVisibility() != 8) {
|
|
LayoutParams layoutParams = (LayoutParams) childAt.getLayoutParams();
|
|
if (z) {
|
|
int absoluteGravity = GravityCompat.getAbsoluteGravity(layoutParams.gravity, layoutDirection);
|
|
if (ViewCompat.getFitsSystemWindows(childAt)) {
|
|
WindowInsets windowInsets = (WindowInsets) this.mLastInsets;
|
|
if (absoluteGravity == 3) {
|
|
windowInsets = windowInsets.replaceSystemWindowInsets(windowInsets.getSystemWindowInsetLeft(), windowInsets.getSystemWindowInsetTop(), 0, windowInsets.getSystemWindowInsetBottom());
|
|
} else if (absoluteGravity == 5) {
|
|
windowInsets = windowInsets.replaceSystemWindowInsets(0, windowInsets.getSystemWindowInsetTop(), windowInsets.getSystemWindowInsetRight(), windowInsets.getSystemWindowInsetBottom());
|
|
}
|
|
childAt.dispatchApplyWindowInsets(windowInsets);
|
|
} else {
|
|
WindowInsets windowInsets2 = (WindowInsets) this.mLastInsets;
|
|
if (absoluteGravity == 3) {
|
|
windowInsets2 = windowInsets2.replaceSystemWindowInsets(windowInsets2.getSystemWindowInsetLeft(), windowInsets2.getSystemWindowInsetTop(), 0, windowInsets2.getSystemWindowInsetBottom());
|
|
} else if (absoluteGravity == 5) {
|
|
windowInsets2 = windowInsets2.replaceSystemWindowInsets(0, windowInsets2.getSystemWindowInsetTop(), windowInsets2.getSystemWindowInsetRight(), windowInsets2.getSystemWindowInsetBottom());
|
|
}
|
|
layoutParams.leftMargin = windowInsets2.getSystemWindowInsetLeft();
|
|
layoutParams.topMargin = windowInsets2.getSystemWindowInsetTop();
|
|
layoutParams.rightMargin = windowInsets2.getSystemWindowInsetRight();
|
|
layoutParams.bottomMargin = windowInsets2.getSystemWindowInsetBottom();
|
|
}
|
|
}
|
|
if (isContentView(childAt)) {
|
|
childAt.measure(View.MeasureSpec.makeMeasureSpec((size - layoutParams.leftMargin) - layoutParams.rightMargin, BasicMeasure.EXACTLY), View.MeasureSpec.makeMeasureSpec((size2 - layoutParams.topMargin) - layoutParams.bottomMargin, BasicMeasure.EXACTLY));
|
|
} else if (isDrawerView(childAt)) {
|
|
if (SET_DRAWER_SHADOW_FROM_ELEVATION) {
|
|
float elevation = ViewCompat.getElevation(childAt);
|
|
float f = this.mDrawerElevation;
|
|
if (elevation != f) {
|
|
ViewCompat.setElevation(childAt, f);
|
|
}
|
|
}
|
|
int drawerViewAbsoluteGravity = getDrawerViewAbsoluteGravity(childAt) & 7;
|
|
boolean z4 = drawerViewAbsoluteGravity == 3 ? CHILDREN_DISALLOW_INTERCEPT : false;
|
|
if ((z4 && z2) || (!z4 && z3)) {
|
|
throw new IllegalStateException("Child drawer has absolute gravity " + gravityToString(drawerViewAbsoluteGravity) + " but this DrawerLayout already has a drawer view along that edge");
|
|
}
|
|
if (z4) {
|
|
z2 = CHILDREN_DISALLOW_INTERCEPT;
|
|
} else {
|
|
z3 = CHILDREN_DISALLOW_INTERCEPT;
|
|
}
|
|
childAt.measure(getChildMeasureSpec(i, this.mMinDrawerMargin + layoutParams.leftMargin + layoutParams.rightMargin, layoutParams.width), getChildMeasureSpec(i2, layoutParams.topMargin + layoutParams.bottomMargin, layoutParams.height));
|
|
} else {
|
|
throw new IllegalStateException("Child " + childAt + " at index " + i3 + " does not have a valid layout_gravity - must be Gravity.LEFT, Gravity.RIGHT or Gravity.NO_GRAVITY");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void resolveShadowDrawables() {
|
|
if (SET_DRAWER_SHADOW_FROM_ELEVATION) {
|
|
return;
|
|
}
|
|
this.mShadowLeftResolved = resolveLeftShadow();
|
|
this.mShadowRightResolved = resolveRightShadow();
|
|
}
|
|
|
|
private Drawable resolveLeftShadow() {
|
|
int layoutDirection = ViewCompat.getLayoutDirection(this);
|
|
if (layoutDirection == 0) {
|
|
Drawable drawable = this.mShadowStart;
|
|
if (drawable != null) {
|
|
mirror(drawable, layoutDirection);
|
|
return this.mShadowStart;
|
|
}
|
|
} else {
|
|
Drawable drawable2 = this.mShadowEnd;
|
|
if (drawable2 != null) {
|
|
mirror(drawable2, layoutDirection);
|
|
return this.mShadowEnd;
|
|
}
|
|
}
|
|
return this.mShadowLeft;
|
|
}
|
|
|
|
private Drawable resolveRightShadow() {
|
|
int layoutDirection = ViewCompat.getLayoutDirection(this);
|
|
if (layoutDirection == 0) {
|
|
Drawable drawable = this.mShadowEnd;
|
|
if (drawable != null) {
|
|
mirror(drawable, layoutDirection);
|
|
return this.mShadowEnd;
|
|
}
|
|
} else {
|
|
Drawable drawable2 = this.mShadowStart;
|
|
if (drawable2 != null) {
|
|
mirror(drawable2, layoutDirection);
|
|
return this.mShadowStart;
|
|
}
|
|
}
|
|
return this.mShadowRight;
|
|
}
|
|
|
|
private void mirror(Drawable drawable, int i) {
|
|
if (drawable == null || !DrawableCompat.isAutoMirrored(drawable)) {
|
|
return;
|
|
}
|
|
DrawableCompat.setLayoutDirection(drawable, i);
|
|
}
|
|
|
|
/* JADX WARN: Code restructure failed: missing block: B:46:0x00db, code lost:
|
|
|
|
r1 = getRootWindowInsets();
|
|
*/
|
|
@Override // android.view.ViewGroup, android.view.View
|
|
/*
|
|
Code decompiled incorrectly, please refer to instructions dump.
|
|
To view partially-correct add '--show-bad-code' argument
|
|
*/
|
|
protected void onLayout(boolean r17, int r18, int r19, int r20, int r21) {
|
|
/*
|
|
Method dump skipped, instructions count: 268
|
|
To view this dump add '--comments-level debug' option
|
|
*/
|
|
throw new UnsupportedOperationException("Method not decompiled: androidx.drawerlayout.widget.DrawerLayout.onLayout(boolean, int, int, int, int):void");
|
|
}
|
|
|
|
@Override // android.view.View, android.view.ViewParent
|
|
public void requestLayout() {
|
|
if (this.mInLayout) {
|
|
return;
|
|
}
|
|
super.requestLayout();
|
|
}
|
|
|
|
@Override // android.view.View
|
|
public void computeScroll() {
|
|
int childCount = getChildCount();
|
|
float f = 0.0f;
|
|
for (int i = 0; i < childCount; i++) {
|
|
f = Math.max(f, ((LayoutParams) getChildAt(i).getLayoutParams()).onScreen);
|
|
}
|
|
this.mScrimOpacity = f;
|
|
boolean continueSettling = this.mLeftDragger.continueSettling(CHILDREN_DISALLOW_INTERCEPT);
|
|
boolean continueSettling2 = this.mRightDragger.continueSettling(CHILDREN_DISALLOW_INTERCEPT);
|
|
if (continueSettling || continueSettling2) {
|
|
ViewCompat.postInvalidateOnAnimation(this);
|
|
}
|
|
}
|
|
|
|
private static boolean hasOpaqueBackground(View view) {
|
|
Drawable background = view.getBackground();
|
|
if (background == null || background.getOpacity() != -1) {
|
|
return false;
|
|
}
|
|
return CHILDREN_DISALLOW_INTERCEPT;
|
|
}
|
|
|
|
public void setStatusBarBackground(Drawable drawable) {
|
|
this.mStatusBarBackground = drawable;
|
|
invalidate();
|
|
}
|
|
|
|
public void setStatusBarBackground(int i) {
|
|
this.mStatusBarBackground = i != 0 ? ContextCompat.getDrawable(getContext(), i) : null;
|
|
invalidate();
|
|
}
|
|
|
|
public void setStatusBarBackgroundColor(int i) {
|
|
this.mStatusBarBackground = new ColorDrawable(i);
|
|
invalidate();
|
|
}
|
|
|
|
@Override // android.view.View
|
|
public void onRtlPropertiesChanged(int i) {
|
|
resolveShadowDrawables();
|
|
}
|
|
|
|
@Override // android.view.View
|
|
public void onDraw(Canvas canvas) {
|
|
super.onDraw(canvas);
|
|
if (!this.mDrawStatusBarBackground || this.mStatusBarBackground == null) {
|
|
return;
|
|
}
|
|
Object obj = this.mLastInsets;
|
|
int systemWindowInsetTop = obj != null ? ((WindowInsets) obj).getSystemWindowInsetTop() : 0;
|
|
if (systemWindowInsetTop > 0) {
|
|
this.mStatusBarBackground.setBounds(0, 0, getWidth(), systemWindowInsetTop);
|
|
this.mStatusBarBackground.draw(canvas);
|
|
}
|
|
}
|
|
|
|
@Override // android.view.ViewGroup
|
|
protected boolean drawChild(Canvas canvas, View view, long j) {
|
|
int height = getHeight();
|
|
boolean isContentView = isContentView(view);
|
|
int width = getWidth();
|
|
int save = canvas.save();
|
|
int i = 0;
|
|
if (isContentView) {
|
|
int childCount = getChildCount();
|
|
int i2 = 0;
|
|
for (int i3 = 0; i3 < childCount; i3++) {
|
|
View childAt = getChildAt(i3);
|
|
if (childAt != view && childAt.getVisibility() == 0 && hasOpaqueBackground(childAt) && isDrawerView(childAt) && childAt.getHeight() >= height) {
|
|
if (checkDrawerViewAbsoluteGravity(childAt, 3)) {
|
|
int right = childAt.getRight();
|
|
if (right > i2) {
|
|
i2 = right;
|
|
}
|
|
} else {
|
|
int left = childAt.getLeft();
|
|
if (left < width) {
|
|
width = left;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
canvas.clipRect(i2, 0, width, getHeight());
|
|
i = i2;
|
|
}
|
|
boolean drawChild = super.drawChild(canvas, view, j);
|
|
canvas.restoreToCount(save);
|
|
float f = this.mScrimOpacity;
|
|
if (f > 0.0f && isContentView) {
|
|
this.mScrimPaint.setColor((this.mScrimColor & ViewCompat.MEASURED_SIZE_MASK) | (((int) ((((-16777216) & r2) >>> 24) * f)) << 24));
|
|
canvas.drawRect(i, 0.0f, width, getHeight(), this.mScrimPaint);
|
|
} else if (this.mShadowLeftResolved != null && checkDrawerViewAbsoluteGravity(view, 3)) {
|
|
int intrinsicWidth = this.mShadowLeftResolved.getIntrinsicWidth();
|
|
int right2 = view.getRight();
|
|
float max = Math.max(0.0f, Math.min(right2 / this.mLeftDragger.getEdgeSize(), 1.0f));
|
|
this.mShadowLeftResolved.setBounds(right2, view.getTop(), intrinsicWidth + right2, view.getBottom());
|
|
this.mShadowLeftResolved.setAlpha((int) (max * 255.0f));
|
|
this.mShadowLeftResolved.draw(canvas);
|
|
} else if (this.mShadowRightResolved != null && checkDrawerViewAbsoluteGravity(view, 5)) {
|
|
int intrinsicWidth2 = this.mShadowRightResolved.getIntrinsicWidth();
|
|
int left2 = view.getLeft();
|
|
float max2 = Math.max(0.0f, Math.min((getWidth() - left2) / this.mRightDragger.getEdgeSize(), 1.0f));
|
|
this.mShadowRightResolved.setBounds(left2 - intrinsicWidth2, view.getTop(), left2, view.getBottom());
|
|
this.mShadowRightResolved.setAlpha((int) (max2 * 255.0f));
|
|
this.mShadowRightResolved.draw(canvas);
|
|
}
|
|
return drawChild;
|
|
}
|
|
|
|
boolean isContentView(View view) {
|
|
if (((LayoutParams) view.getLayoutParams()).gravity == 0) {
|
|
return CHILDREN_DISALLOW_INTERCEPT;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
boolean isDrawerView(View view) {
|
|
int absoluteGravity = GravityCompat.getAbsoluteGravity(((LayoutParams) view.getLayoutParams()).gravity, ViewCompat.getLayoutDirection(view));
|
|
if ((absoluteGravity & 3) == 0 && (absoluteGravity & 5) == 0) {
|
|
return false;
|
|
}
|
|
return CHILDREN_DISALLOW_INTERCEPT;
|
|
}
|
|
|
|
/* JADX WARN: Code restructure failed: missing block: B:6:0x001b, code lost:
|
|
|
|
if (r0 != 3) goto L13;
|
|
*/
|
|
@Override // android.view.ViewGroup
|
|
/*
|
|
Code decompiled incorrectly, please refer to instructions dump.
|
|
To view partially-correct add '--show-bad-code' argument
|
|
*/
|
|
public boolean onInterceptTouchEvent(android.view.MotionEvent r7) {
|
|
/*
|
|
r6 = this;
|
|
int r0 = r7.getActionMasked()
|
|
androidx.customview.widget.ViewDragHelper r1 = r6.mLeftDragger
|
|
boolean r1 = r1.shouldInterceptTouchEvent(r7)
|
|
androidx.customview.widget.ViewDragHelper r2 = r6.mRightDragger
|
|
boolean r2 = r2.shouldInterceptTouchEvent(r7)
|
|
r1 = r1 | r2
|
|
r2 = 1
|
|
r3 = 0
|
|
if (r0 == 0) goto L38
|
|
if (r0 == r2) goto L31
|
|
r7 = 2
|
|
r4 = 3
|
|
if (r0 == r7) goto L1e
|
|
if (r0 == r4) goto L31
|
|
goto L36
|
|
L1e:
|
|
androidx.customview.widget.ViewDragHelper r7 = r6.mLeftDragger
|
|
boolean r7 = r7.checkTouchSlop(r4)
|
|
if (r7 == 0) goto L36
|
|
androidx.drawerlayout.widget.DrawerLayout$ViewDragCallback r7 = r6.mLeftCallback
|
|
r7.removeCallbacks()
|
|
androidx.drawerlayout.widget.DrawerLayout$ViewDragCallback r7 = r6.mRightCallback
|
|
r7.removeCallbacks()
|
|
goto L36
|
|
L31:
|
|
r6.closeDrawers(r2)
|
|
r6.mChildrenCanceledTouch = r3
|
|
L36:
|
|
r7 = 0
|
|
goto L60
|
|
L38:
|
|
float r0 = r7.getX()
|
|
float r7 = r7.getY()
|
|
r6.mInitialMotionX = r0
|
|
r6.mInitialMotionY = r7
|
|
float r4 = r6.mScrimOpacity
|
|
r5 = 0
|
|
int r4 = (r4 > r5 ? 1 : (r4 == r5 ? 0 : -1))
|
|
if (r4 <= 0) goto L5d
|
|
androidx.customview.widget.ViewDragHelper r4 = r6.mLeftDragger
|
|
int r0 = (int) r0
|
|
int r7 = (int) r7
|
|
android.view.View r7 = r4.findTopChildUnder(r0, r7)
|
|
if (r7 == 0) goto L5d
|
|
boolean r7 = r6.isContentView(r7)
|
|
if (r7 == 0) goto L5d
|
|
r7 = 1
|
|
goto L5e
|
|
L5d:
|
|
r7 = 0
|
|
L5e:
|
|
r6.mChildrenCanceledTouch = r3
|
|
L60:
|
|
if (r1 != 0) goto L70
|
|
if (r7 != 0) goto L70
|
|
boolean r7 = r6.hasPeekingDrawer()
|
|
if (r7 != 0) goto L70
|
|
boolean r7 = r6.mChildrenCanceledTouch
|
|
if (r7 == 0) goto L6f
|
|
goto L70
|
|
L6f:
|
|
r2 = 0
|
|
L70:
|
|
return r2
|
|
*/
|
|
throw new UnsupportedOperationException("Method not decompiled: androidx.drawerlayout.widget.DrawerLayout.onInterceptTouchEvent(android.view.MotionEvent):boolean");
|
|
}
|
|
|
|
@Override // android.view.View
|
|
public boolean dispatchGenericMotionEvent(MotionEvent motionEvent) {
|
|
if ((motionEvent.getSource() & 2) == 0 || motionEvent.getAction() == 10 || this.mScrimOpacity <= 0.0f) {
|
|
return super.dispatchGenericMotionEvent(motionEvent);
|
|
}
|
|
int childCount = getChildCount();
|
|
if (childCount == 0) {
|
|
return false;
|
|
}
|
|
float x = motionEvent.getX();
|
|
float y = motionEvent.getY();
|
|
for (int i = childCount - 1; i >= 0; i--) {
|
|
View childAt = getChildAt(i);
|
|
if (isInBoundsOfChild(x, y, childAt) && !isContentView(childAt) && dispatchTransformedGenericPointerEvent(motionEvent, childAt)) {
|
|
return CHILDREN_DISALLOW_INTERCEPT;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/* JADX WARN: Code restructure failed: missing block: B:18:0x005b, code lost:
|
|
|
|
if (getDrawerLockMode(r7) != 2) goto L20;
|
|
*/
|
|
@Override // android.view.View
|
|
/*
|
|
Code decompiled incorrectly, please refer to instructions dump.
|
|
To view partially-correct add '--show-bad-code' argument
|
|
*/
|
|
public boolean onTouchEvent(android.view.MotionEvent r7) {
|
|
/*
|
|
r6 = this;
|
|
androidx.customview.widget.ViewDragHelper r0 = r6.mLeftDragger
|
|
r0.processTouchEvent(r7)
|
|
androidx.customview.widget.ViewDragHelper r0 = r6.mRightDragger
|
|
r0.processTouchEvent(r7)
|
|
int r0 = r7.getAction()
|
|
r0 = r0 & 255(0xff, float:3.57E-43)
|
|
r1 = 0
|
|
r2 = 1
|
|
if (r0 == 0) goto L62
|
|
if (r0 == r2) goto L20
|
|
r7 = 3
|
|
if (r0 == r7) goto L1a
|
|
goto L70
|
|
L1a:
|
|
r6.closeDrawers(r2)
|
|
r6.mChildrenCanceledTouch = r1
|
|
goto L70
|
|
L20:
|
|
float r0 = r7.getX()
|
|
float r7 = r7.getY()
|
|
androidx.customview.widget.ViewDragHelper r3 = r6.mLeftDragger
|
|
int r4 = (int) r0
|
|
int r5 = (int) r7
|
|
android.view.View r3 = r3.findTopChildUnder(r4, r5)
|
|
if (r3 == 0) goto L5d
|
|
boolean r3 = r6.isContentView(r3)
|
|
if (r3 == 0) goto L5d
|
|
float r3 = r6.mInitialMotionX
|
|
float r0 = r0 - r3
|
|
float r3 = r6.mInitialMotionY
|
|
float r7 = r7 - r3
|
|
androidx.customview.widget.ViewDragHelper r3 = r6.mLeftDragger
|
|
int r3 = r3.getTouchSlop()
|
|
float r0 = r0 * r0
|
|
float r7 = r7 * r7
|
|
float r0 = r0 + r7
|
|
int r3 = r3 * r3
|
|
float r7 = (float) r3
|
|
int r7 = (r0 > r7 ? 1 : (r0 == r7 ? 0 : -1))
|
|
if (r7 >= 0) goto L5d
|
|
android.view.View r7 = r6.findOpenDrawer()
|
|
if (r7 == 0) goto L5d
|
|
int r7 = r6.getDrawerLockMode(r7)
|
|
r0 = 2
|
|
if (r7 != r0) goto L5e
|
|
L5d:
|
|
r1 = 1
|
|
L5e:
|
|
r6.closeDrawers(r1)
|
|
goto L70
|
|
L62:
|
|
float r0 = r7.getX()
|
|
float r7 = r7.getY()
|
|
r6.mInitialMotionX = r0
|
|
r6.mInitialMotionY = r7
|
|
r6.mChildrenCanceledTouch = r1
|
|
L70:
|
|
return r2
|
|
*/
|
|
throw new UnsupportedOperationException("Method not decompiled: androidx.drawerlayout.widget.DrawerLayout.onTouchEvent(android.view.MotionEvent):boolean");
|
|
}
|
|
|
|
@Override // android.view.ViewGroup, android.view.ViewParent
|
|
public void requestDisallowInterceptTouchEvent(boolean z) {
|
|
super.requestDisallowInterceptTouchEvent(z);
|
|
if (z) {
|
|
closeDrawers(CHILDREN_DISALLOW_INTERCEPT);
|
|
}
|
|
}
|
|
|
|
public void closeDrawers() {
|
|
closeDrawers(false);
|
|
}
|
|
|
|
void closeDrawers(boolean z) {
|
|
boolean smoothSlideViewTo;
|
|
int childCount = getChildCount();
|
|
boolean z2 = false;
|
|
for (int i = 0; i < childCount; i++) {
|
|
View childAt = getChildAt(i);
|
|
LayoutParams layoutParams = (LayoutParams) childAt.getLayoutParams();
|
|
if (isDrawerView(childAt) && (!z || layoutParams.isPeeking)) {
|
|
int width = childAt.getWidth();
|
|
if (checkDrawerViewAbsoluteGravity(childAt, 3)) {
|
|
smoothSlideViewTo = this.mLeftDragger.smoothSlideViewTo(childAt, -width, childAt.getTop());
|
|
} else {
|
|
smoothSlideViewTo = this.mRightDragger.smoothSlideViewTo(childAt, getWidth(), childAt.getTop());
|
|
}
|
|
z2 |= smoothSlideViewTo;
|
|
layoutParams.isPeeking = false;
|
|
}
|
|
}
|
|
this.mLeftCallback.removeCallbacks();
|
|
this.mRightCallback.removeCallbacks();
|
|
if (z2) {
|
|
invalidate();
|
|
}
|
|
}
|
|
|
|
@Override // androidx.customview.widget.Openable
|
|
public void open() {
|
|
openDrawer(GravityCompat.START);
|
|
}
|
|
|
|
public void openDrawer(View view) {
|
|
openDrawer(view, CHILDREN_DISALLOW_INTERCEPT);
|
|
}
|
|
|
|
public void openDrawer(View view, boolean z) {
|
|
if (!isDrawerView(view)) {
|
|
throw new IllegalArgumentException("View " + view + " is not a sliding drawer");
|
|
}
|
|
LayoutParams layoutParams = (LayoutParams) view.getLayoutParams();
|
|
if (this.mFirstLayout) {
|
|
layoutParams.onScreen = 1.0f;
|
|
layoutParams.openState = 1;
|
|
updateChildrenImportantForAccessibility(view, CHILDREN_DISALLOW_INTERCEPT);
|
|
updateChildAccessibilityAction(view);
|
|
} else if (z) {
|
|
layoutParams.openState |= 2;
|
|
if (checkDrawerViewAbsoluteGravity(view, 3)) {
|
|
this.mLeftDragger.smoothSlideViewTo(view, 0, view.getTop());
|
|
} else {
|
|
this.mRightDragger.smoothSlideViewTo(view, getWidth() - view.getWidth(), view.getTop());
|
|
}
|
|
} else {
|
|
moveDrawerToOffset(view, 1.0f);
|
|
updateDrawerState(0, view);
|
|
view.setVisibility(0);
|
|
}
|
|
invalidate();
|
|
}
|
|
|
|
public void openDrawer(int i) {
|
|
openDrawer(i, CHILDREN_DISALLOW_INTERCEPT);
|
|
}
|
|
|
|
public void openDrawer(int i, boolean z) {
|
|
View findDrawerWithGravity = findDrawerWithGravity(i);
|
|
if (findDrawerWithGravity == null) {
|
|
throw new IllegalArgumentException("No drawer view found with gravity " + gravityToString(i));
|
|
}
|
|
openDrawer(findDrawerWithGravity, z);
|
|
}
|
|
|
|
@Override // androidx.customview.widget.Openable
|
|
public void close() {
|
|
closeDrawer(GravityCompat.START);
|
|
}
|
|
|
|
public void closeDrawer(View view) {
|
|
closeDrawer(view, CHILDREN_DISALLOW_INTERCEPT);
|
|
}
|
|
|
|
public void closeDrawer(View view, boolean z) {
|
|
if (!isDrawerView(view)) {
|
|
throw new IllegalArgumentException("View " + view + " is not a sliding drawer");
|
|
}
|
|
LayoutParams layoutParams = (LayoutParams) view.getLayoutParams();
|
|
if (this.mFirstLayout) {
|
|
layoutParams.onScreen = 0.0f;
|
|
layoutParams.openState = 0;
|
|
} else if (z) {
|
|
layoutParams.openState |= 4;
|
|
if (checkDrawerViewAbsoluteGravity(view, 3)) {
|
|
this.mLeftDragger.smoothSlideViewTo(view, -view.getWidth(), view.getTop());
|
|
} else {
|
|
this.mRightDragger.smoothSlideViewTo(view, getWidth(), view.getTop());
|
|
}
|
|
} else {
|
|
moveDrawerToOffset(view, 0.0f);
|
|
updateDrawerState(0, view);
|
|
view.setVisibility(4);
|
|
}
|
|
invalidate();
|
|
}
|
|
|
|
public void closeDrawer(int i) {
|
|
closeDrawer(i, CHILDREN_DISALLOW_INTERCEPT);
|
|
}
|
|
|
|
public void closeDrawer(int i, boolean z) {
|
|
View findDrawerWithGravity = findDrawerWithGravity(i);
|
|
if (findDrawerWithGravity == null) {
|
|
throw new IllegalArgumentException("No drawer view found with gravity " + gravityToString(i));
|
|
}
|
|
closeDrawer(findDrawerWithGravity, z);
|
|
}
|
|
|
|
public boolean isDrawerOpen(View view) {
|
|
if (!isDrawerView(view)) {
|
|
throw new IllegalArgumentException("View " + view + " is not a drawer");
|
|
}
|
|
if ((((LayoutParams) view.getLayoutParams()).openState & 1) == 1) {
|
|
return CHILDREN_DISALLOW_INTERCEPT;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@Override // androidx.customview.widget.Openable
|
|
public boolean isOpen() {
|
|
return isDrawerOpen(GravityCompat.START);
|
|
}
|
|
|
|
public boolean isDrawerOpen(int i) {
|
|
View findDrawerWithGravity = findDrawerWithGravity(i);
|
|
if (findDrawerWithGravity != null) {
|
|
return isDrawerOpen(findDrawerWithGravity);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean isDrawerVisible(View view) {
|
|
if (isDrawerView(view)) {
|
|
if (((LayoutParams) view.getLayoutParams()).onScreen > 0.0f) {
|
|
return CHILDREN_DISALLOW_INTERCEPT;
|
|
}
|
|
return false;
|
|
}
|
|
throw new IllegalArgumentException("View " + view + " is not a drawer");
|
|
}
|
|
|
|
public boolean isDrawerVisible(int i) {
|
|
View findDrawerWithGravity = findDrawerWithGravity(i);
|
|
if (findDrawerWithGravity != null) {
|
|
return isDrawerVisible(findDrawerWithGravity);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private boolean hasPeekingDrawer() {
|
|
int childCount = getChildCount();
|
|
for (int i = 0; i < childCount; i++) {
|
|
if (((LayoutParams) getChildAt(i).getLayoutParams()).isPeeking) {
|
|
return CHILDREN_DISALLOW_INTERCEPT;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@Override // android.view.ViewGroup
|
|
protected ViewGroup.LayoutParams generateDefaultLayoutParams() {
|
|
return new LayoutParams(-1, -1);
|
|
}
|
|
|
|
@Override // android.view.ViewGroup
|
|
protected ViewGroup.LayoutParams generateLayoutParams(ViewGroup.LayoutParams layoutParams) {
|
|
if (layoutParams instanceof LayoutParams) {
|
|
return new LayoutParams((LayoutParams) layoutParams);
|
|
}
|
|
if (layoutParams instanceof ViewGroup.MarginLayoutParams) {
|
|
return new LayoutParams((ViewGroup.MarginLayoutParams) layoutParams);
|
|
}
|
|
return new LayoutParams(layoutParams);
|
|
}
|
|
|
|
@Override // android.view.ViewGroup
|
|
protected boolean checkLayoutParams(ViewGroup.LayoutParams layoutParams) {
|
|
if ((layoutParams instanceof LayoutParams) && super.checkLayoutParams(layoutParams)) {
|
|
return CHILDREN_DISALLOW_INTERCEPT;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@Override // android.view.ViewGroup
|
|
public ViewGroup.LayoutParams generateLayoutParams(AttributeSet attributeSet) {
|
|
return new LayoutParams(getContext(), attributeSet);
|
|
}
|
|
|
|
@Override // android.view.ViewGroup, android.view.View
|
|
public void addFocusables(ArrayList<View> arrayList, int i, int i2) {
|
|
if (getDescendantFocusability() == 393216) {
|
|
return;
|
|
}
|
|
int childCount = getChildCount();
|
|
boolean z = false;
|
|
for (int i3 = 0; i3 < childCount; i3++) {
|
|
View childAt = getChildAt(i3);
|
|
if (isDrawerView(childAt)) {
|
|
if (isDrawerOpen(childAt)) {
|
|
childAt.addFocusables(arrayList, i, i2);
|
|
z = CHILDREN_DISALLOW_INTERCEPT;
|
|
}
|
|
} else {
|
|
this.mNonDrawerViews.add(childAt);
|
|
}
|
|
}
|
|
if (!z) {
|
|
int size = this.mNonDrawerViews.size();
|
|
for (int i4 = 0; i4 < size; i4++) {
|
|
View view = this.mNonDrawerViews.get(i4);
|
|
if (view.getVisibility() == 0) {
|
|
view.addFocusables(arrayList, i, i2);
|
|
}
|
|
}
|
|
}
|
|
this.mNonDrawerViews.clear();
|
|
}
|
|
|
|
private boolean hasVisibleDrawer() {
|
|
if (findVisibleDrawer() != null) {
|
|
return CHILDREN_DISALLOW_INTERCEPT;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
View findVisibleDrawer() {
|
|
int childCount = getChildCount();
|
|
for (int i = 0; i < childCount; i++) {
|
|
View childAt = getChildAt(i);
|
|
if (isDrawerView(childAt) && isDrawerVisible(childAt)) {
|
|
return childAt;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
void cancelChildViewTouch() {
|
|
if (this.mChildrenCanceledTouch) {
|
|
return;
|
|
}
|
|
long uptimeMillis = SystemClock.uptimeMillis();
|
|
MotionEvent obtain = MotionEvent.obtain(uptimeMillis, uptimeMillis, 3, 0.0f, 0.0f, 0);
|
|
int childCount = getChildCount();
|
|
for (int i = 0; i < childCount; i++) {
|
|
getChildAt(i).dispatchTouchEvent(obtain);
|
|
}
|
|
obtain.recycle();
|
|
this.mChildrenCanceledTouch = CHILDREN_DISALLOW_INTERCEPT;
|
|
}
|
|
|
|
@Override // android.view.View, android.view.KeyEvent.Callback
|
|
public boolean onKeyDown(int i, KeyEvent keyEvent) {
|
|
if (i == 4 && hasVisibleDrawer()) {
|
|
keyEvent.startTracking();
|
|
return CHILDREN_DISALLOW_INTERCEPT;
|
|
}
|
|
return super.onKeyDown(i, keyEvent);
|
|
}
|
|
|
|
@Override // android.view.View, android.view.KeyEvent.Callback
|
|
public boolean onKeyUp(int i, KeyEvent keyEvent) {
|
|
if (i == 4) {
|
|
View findVisibleDrawer = findVisibleDrawer();
|
|
if (findVisibleDrawer != null && getDrawerLockMode(findVisibleDrawer) == 0) {
|
|
closeDrawers();
|
|
}
|
|
if (findVisibleDrawer != null) {
|
|
return CHILDREN_DISALLOW_INTERCEPT;
|
|
}
|
|
return false;
|
|
}
|
|
return super.onKeyUp(i, keyEvent);
|
|
}
|
|
|
|
@Override // android.view.View
|
|
protected void onRestoreInstanceState(Parcelable parcelable) {
|
|
View findDrawerWithGravity;
|
|
if (!(parcelable instanceof SavedState)) {
|
|
super.onRestoreInstanceState(parcelable);
|
|
return;
|
|
}
|
|
SavedState savedState = (SavedState) parcelable;
|
|
super.onRestoreInstanceState(savedState.getSuperState());
|
|
if (savedState.openDrawerGravity != 0 && (findDrawerWithGravity = findDrawerWithGravity(savedState.openDrawerGravity)) != null) {
|
|
openDrawer(findDrawerWithGravity);
|
|
}
|
|
if (savedState.lockModeLeft != 3) {
|
|
setDrawerLockMode(savedState.lockModeLeft, 3);
|
|
}
|
|
if (savedState.lockModeRight != 3) {
|
|
setDrawerLockMode(savedState.lockModeRight, 5);
|
|
}
|
|
if (savedState.lockModeStart != 3) {
|
|
setDrawerLockMode(savedState.lockModeStart, GravityCompat.START);
|
|
}
|
|
if (savedState.lockModeEnd != 3) {
|
|
setDrawerLockMode(savedState.lockModeEnd, GravityCompat.END);
|
|
}
|
|
}
|
|
|
|
@Override // android.view.View
|
|
protected Parcelable onSaveInstanceState() {
|
|
SavedState savedState = new SavedState(super.onSaveInstanceState());
|
|
int childCount = getChildCount();
|
|
for (int i = 0; i < childCount; i++) {
|
|
LayoutParams layoutParams = (LayoutParams) getChildAt(i).getLayoutParams();
|
|
int i2 = layoutParams.openState;
|
|
boolean z = CHILDREN_DISALLOW_INTERCEPT;
|
|
boolean z2 = i2 == 1 ? CHILDREN_DISALLOW_INTERCEPT : false;
|
|
if (layoutParams.openState != 2) {
|
|
z = false;
|
|
}
|
|
if (z2 || z) {
|
|
savedState.openDrawerGravity = layoutParams.gravity;
|
|
break;
|
|
}
|
|
}
|
|
savedState.lockModeLeft = this.mLockModeLeft;
|
|
savedState.lockModeRight = this.mLockModeRight;
|
|
savedState.lockModeStart = this.mLockModeStart;
|
|
savedState.lockModeEnd = this.mLockModeEnd;
|
|
return savedState;
|
|
}
|
|
|
|
@Override // android.view.ViewGroup
|
|
public void addView(View view, int i, ViewGroup.LayoutParams layoutParams) {
|
|
super.addView(view, i, layoutParams);
|
|
if (findOpenDrawer() != null || isDrawerView(view)) {
|
|
ViewCompat.setImportantForAccessibility(view, 4);
|
|
} else {
|
|
ViewCompat.setImportantForAccessibility(view, 1);
|
|
}
|
|
if (CAN_HIDE_DESCENDANTS) {
|
|
return;
|
|
}
|
|
ViewCompat.setAccessibilityDelegate(view, this.mChildAccessibilityDelegate);
|
|
}
|
|
|
|
static boolean includeChildForAccessibility(View view) {
|
|
if (ViewCompat.getImportantForAccessibility(view) == 4 || ViewCompat.getImportantForAccessibility(view) == 2) {
|
|
return false;
|
|
}
|
|
return CHILDREN_DISALLOW_INTERCEPT;
|
|
}
|
|
|
|
protected static class SavedState extends AbsSavedState {
|
|
public static final Parcelable.Creator<SavedState> CREATOR = new Parcelable.ClassLoaderCreator<SavedState>() { // from class: androidx.drawerlayout.widget.DrawerLayout.SavedState.1
|
|
/* JADX WARN: Can't rename method to resolve collision */
|
|
@Override // android.os.Parcelable.ClassLoaderCreator
|
|
public SavedState createFromParcel(Parcel parcel, ClassLoader classLoader) {
|
|
return new SavedState(parcel, classLoader);
|
|
}
|
|
|
|
@Override // android.os.Parcelable.Creator
|
|
public SavedState createFromParcel(Parcel parcel) {
|
|
return new SavedState(parcel, null);
|
|
}
|
|
|
|
@Override // android.os.Parcelable.Creator
|
|
public SavedState[] newArray(int i) {
|
|
return new SavedState[i];
|
|
}
|
|
};
|
|
int lockModeEnd;
|
|
int lockModeLeft;
|
|
int lockModeRight;
|
|
int lockModeStart;
|
|
int openDrawerGravity;
|
|
|
|
public SavedState(Parcel parcel, ClassLoader classLoader) {
|
|
super(parcel, classLoader);
|
|
this.openDrawerGravity = 0;
|
|
this.openDrawerGravity = parcel.readInt();
|
|
this.lockModeLeft = parcel.readInt();
|
|
this.lockModeRight = parcel.readInt();
|
|
this.lockModeStart = parcel.readInt();
|
|
this.lockModeEnd = parcel.readInt();
|
|
}
|
|
|
|
public SavedState(Parcelable parcelable) {
|
|
super(parcelable);
|
|
this.openDrawerGravity = 0;
|
|
}
|
|
|
|
@Override // androidx.customview.view.AbsSavedState, android.os.Parcelable
|
|
public void writeToParcel(Parcel parcel, int i) {
|
|
super.writeToParcel(parcel, i);
|
|
parcel.writeInt(this.openDrawerGravity);
|
|
parcel.writeInt(this.lockModeLeft);
|
|
parcel.writeInt(this.lockModeRight);
|
|
parcel.writeInt(this.lockModeStart);
|
|
parcel.writeInt(this.lockModeEnd);
|
|
}
|
|
}
|
|
|
|
private class ViewDragCallback extends ViewDragHelper.Callback {
|
|
private final int mAbsGravity;
|
|
private ViewDragHelper mDragger;
|
|
private final Runnable mPeekRunnable = new Runnable() { // from class: androidx.drawerlayout.widget.DrawerLayout.ViewDragCallback.1
|
|
@Override // java.lang.Runnable
|
|
public void run() {
|
|
ViewDragCallback.this.peekDrawer();
|
|
}
|
|
};
|
|
|
|
@Override // androidx.customview.widget.ViewDragHelper.Callback
|
|
public boolean onEdgeLock(int i) {
|
|
return false;
|
|
}
|
|
|
|
public void setDragger(ViewDragHelper viewDragHelper) {
|
|
this.mDragger = viewDragHelper;
|
|
}
|
|
|
|
ViewDragCallback(int i) {
|
|
this.mAbsGravity = i;
|
|
}
|
|
|
|
public void removeCallbacks() {
|
|
DrawerLayout.this.removeCallbacks(this.mPeekRunnable);
|
|
}
|
|
|
|
@Override // androidx.customview.widget.ViewDragHelper.Callback
|
|
public boolean tryCaptureView(View view, int i) {
|
|
if (DrawerLayout.this.isDrawerView(view) && DrawerLayout.this.checkDrawerViewAbsoluteGravity(view, this.mAbsGravity) && DrawerLayout.this.getDrawerLockMode(view) == 0) {
|
|
return DrawerLayout.CHILDREN_DISALLOW_INTERCEPT;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@Override // androidx.customview.widget.ViewDragHelper.Callback
|
|
public void onViewDragStateChanged(int i) {
|
|
DrawerLayout.this.updateDrawerState(i, this.mDragger.getCapturedView());
|
|
}
|
|
|
|
@Override // androidx.customview.widget.ViewDragHelper.Callback
|
|
public void onViewPositionChanged(View view, int i, int i2, int i3, int i4) {
|
|
float width = (DrawerLayout.this.checkDrawerViewAbsoluteGravity(view, 3) ? i + r3 : DrawerLayout.this.getWidth() - i) / view.getWidth();
|
|
DrawerLayout.this.setDrawerViewOffset(view, width);
|
|
view.setVisibility(width == 0.0f ? 4 : 0);
|
|
DrawerLayout.this.invalidate();
|
|
}
|
|
|
|
@Override // androidx.customview.widget.ViewDragHelper.Callback
|
|
public void onViewCaptured(View view, int i) {
|
|
((LayoutParams) view.getLayoutParams()).isPeeking = false;
|
|
closeOtherDrawer();
|
|
}
|
|
|
|
private void closeOtherDrawer() {
|
|
View findDrawerWithGravity = DrawerLayout.this.findDrawerWithGravity(this.mAbsGravity == 3 ? 5 : 3);
|
|
if (findDrawerWithGravity != null) {
|
|
DrawerLayout.this.closeDrawer(findDrawerWithGravity);
|
|
}
|
|
}
|
|
|
|
@Override // androidx.customview.widget.ViewDragHelper.Callback
|
|
public void onViewReleased(View view, float f, float f2) {
|
|
int i;
|
|
float drawerViewOffset = DrawerLayout.this.getDrawerViewOffset(view);
|
|
int width = view.getWidth();
|
|
if (DrawerLayout.this.checkDrawerViewAbsoluteGravity(view, 3)) {
|
|
i = (f > 0.0f || (f == 0.0f && drawerViewOffset > 0.5f)) ? 0 : -width;
|
|
} else {
|
|
int width2 = DrawerLayout.this.getWidth();
|
|
if (f < 0.0f || (f == 0.0f && drawerViewOffset > 0.5f)) {
|
|
width2 -= width;
|
|
}
|
|
i = width2;
|
|
}
|
|
this.mDragger.settleCapturedViewAt(i, view.getTop());
|
|
DrawerLayout.this.invalidate();
|
|
}
|
|
|
|
@Override // androidx.customview.widget.ViewDragHelper.Callback
|
|
public void onEdgeTouched(int i, int i2) {
|
|
DrawerLayout.this.postDelayed(this.mPeekRunnable, 160L);
|
|
}
|
|
|
|
void peekDrawer() {
|
|
View findDrawerWithGravity;
|
|
int width;
|
|
int edgeSize = this.mDragger.getEdgeSize();
|
|
boolean z = this.mAbsGravity == 3 ? DrawerLayout.CHILDREN_DISALLOW_INTERCEPT : false;
|
|
if (z) {
|
|
findDrawerWithGravity = DrawerLayout.this.findDrawerWithGravity(3);
|
|
width = (findDrawerWithGravity != null ? -findDrawerWithGravity.getWidth() : 0) + edgeSize;
|
|
} else {
|
|
findDrawerWithGravity = DrawerLayout.this.findDrawerWithGravity(5);
|
|
width = DrawerLayout.this.getWidth() - edgeSize;
|
|
}
|
|
if (findDrawerWithGravity != null) {
|
|
if (((!z || findDrawerWithGravity.getLeft() >= width) && (z || findDrawerWithGravity.getLeft() <= width)) || DrawerLayout.this.getDrawerLockMode(findDrawerWithGravity) != 0) {
|
|
return;
|
|
}
|
|
LayoutParams layoutParams = (LayoutParams) findDrawerWithGravity.getLayoutParams();
|
|
this.mDragger.smoothSlideViewTo(findDrawerWithGravity, width, findDrawerWithGravity.getTop());
|
|
layoutParams.isPeeking = DrawerLayout.CHILDREN_DISALLOW_INTERCEPT;
|
|
DrawerLayout.this.invalidate();
|
|
closeOtherDrawer();
|
|
DrawerLayout.this.cancelChildViewTouch();
|
|
}
|
|
}
|
|
|
|
@Override // androidx.customview.widget.ViewDragHelper.Callback
|
|
public void onEdgeDragStarted(int i, int i2) {
|
|
View findDrawerWithGravity;
|
|
if ((i & 1) == 1) {
|
|
findDrawerWithGravity = DrawerLayout.this.findDrawerWithGravity(3);
|
|
} else {
|
|
findDrawerWithGravity = DrawerLayout.this.findDrawerWithGravity(5);
|
|
}
|
|
if (findDrawerWithGravity == null || DrawerLayout.this.getDrawerLockMode(findDrawerWithGravity) != 0) {
|
|
return;
|
|
}
|
|
this.mDragger.captureChildView(findDrawerWithGravity, i2);
|
|
}
|
|
|
|
@Override // androidx.customview.widget.ViewDragHelper.Callback
|
|
public int getViewHorizontalDragRange(View view) {
|
|
if (DrawerLayout.this.isDrawerView(view)) {
|
|
return view.getWidth();
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
@Override // androidx.customview.widget.ViewDragHelper.Callback
|
|
public int clampViewPositionHorizontal(View view, int i, int i2) {
|
|
if (DrawerLayout.this.checkDrawerViewAbsoluteGravity(view, 3)) {
|
|
return Math.max(-view.getWidth(), Math.min(i, 0));
|
|
}
|
|
int width = DrawerLayout.this.getWidth();
|
|
return Math.max(width - view.getWidth(), Math.min(i, width));
|
|
}
|
|
|
|
@Override // androidx.customview.widget.ViewDragHelper.Callback
|
|
public int clampViewPositionVertical(View view, int i, int i2) {
|
|
return view.getTop();
|
|
}
|
|
}
|
|
|
|
public static class LayoutParams extends ViewGroup.MarginLayoutParams {
|
|
private static final int FLAG_IS_CLOSING = 4;
|
|
private static final int FLAG_IS_OPENED = 1;
|
|
private static final int FLAG_IS_OPENING = 2;
|
|
public int gravity;
|
|
boolean isPeeking;
|
|
float onScreen;
|
|
int openState;
|
|
|
|
public LayoutParams(Context context, AttributeSet attributeSet) {
|
|
super(context, attributeSet);
|
|
this.gravity = 0;
|
|
TypedArray obtainStyledAttributes = context.obtainStyledAttributes(attributeSet, DrawerLayout.LAYOUT_ATTRS);
|
|
this.gravity = obtainStyledAttributes.getInt(0, 0);
|
|
obtainStyledAttributes.recycle();
|
|
}
|
|
|
|
public LayoutParams(int i, int i2) {
|
|
super(i, i2);
|
|
this.gravity = 0;
|
|
}
|
|
|
|
public LayoutParams(int i, int i2, int i3) {
|
|
this(i, i2);
|
|
this.gravity = i3;
|
|
}
|
|
|
|
public LayoutParams(LayoutParams layoutParams) {
|
|
super((ViewGroup.MarginLayoutParams) layoutParams);
|
|
this.gravity = 0;
|
|
this.gravity = layoutParams.gravity;
|
|
}
|
|
|
|
public LayoutParams(ViewGroup.LayoutParams layoutParams) {
|
|
super(layoutParams);
|
|
this.gravity = 0;
|
|
}
|
|
|
|
public LayoutParams(ViewGroup.MarginLayoutParams marginLayoutParams) {
|
|
super(marginLayoutParams);
|
|
this.gravity = 0;
|
|
}
|
|
}
|
|
|
|
class AccessibilityDelegate extends AccessibilityDelegateCompat {
|
|
private final Rect mTmpRect = new Rect();
|
|
|
|
AccessibilityDelegate() {
|
|
}
|
|
|
|
@Override // androidx.core.view.AccessibilityDelegateCompat
|
|
public void onInitializeAccessibilityNodeInfo(View view, AccessibilityNodeInfoCompat accessibilityNodeInfoCompat) {
|
|
if (DrawerLayout.CAN_HIDE_DESCENDANTS) {
|
|
super.onInitializeAccessibilityNodeInfo(view, accessibilityNodeInfoCompat);
|
|
} else {
|
|
AccessibilityNodeInfoCompat obtain = AccessibilityNodeInfoCompat.obtain(accessibilityNodeInfoCompat);
|
|
super.onInitializeAccessibilityNodeInfo(view, obtain);
|
|
accessibilityNodeInfoCompat.setSource(view);
|
|
Object parentForAccessibility = ViewCompat.getParentForAccessibility(view);
|
|
if (parentForAccessibility instanceof View) {
|
|
accessibilityNodeInfoCompat.setParent((View) parentForAccessibility);
|
|
}
|
|
copyNodeInfoNoChildren(accessibilityNodeInfoCompat, obtain);
|
|
obtain.recycle();
|
|
addChildrenForAccessibility(accessibilityNodeInfoCompat, (ViewGroup) view);
|
|
}
|
|
accessibilityNodeInfoCompat.setClassName(DrawerLayout.ACCESSIBILITY_CLASS_NAME);
|
|
accessibilityNodeInfoCompat.setFocusable(false);
|
|
accessibilityNodeInfoCompat.setFocused(false);
|
|
accessibilityNodeInfoCompat.removeAction(AccessibilityNodeInfoCompat.AccessibilityActionCompat.ACTION_FOCUS);
|
|
accessibilityNodeInfoCompat.removeAction(AccessibilityNodeInfoCompat.AccessibilityActionCompat.ACTION_CLEAR_FOCUS);
|
|
}
|
|
|
|
@Override // androidx.core.view.AccessibilityDelegateCompat
|
|
public void onInitializeAccessibilityEvent(View view, AccessibilityEvent accessibilityEvent) {
|
|
super.onInitializeAccessibilityEvent(view, accessibilityEvent);
|
|
accessibilityEvent.setClassName(DrawerLayout.ACCESSIBILITY_CLASS_NAME);
|
|
}
|
|
|
|
@Override // androidx.core.view.AccessibilityDelegateCompat
|
|
public boolean dispatchPopulateAccessibilityEvent(View view, AccessibilityEvent accessibilityEvent) {
|
|
if (accessibilityEvent.getEventType() == 32) {
|
|
List<CharSequence> text = accessibilityEvent.getText();
|
|
View findVisibleDrawer = DrawerLayout.this.findVisibleDrawer();
|
|
if (findVisibleDrawer == null) {
|
|
return DrawerLayout.CHILDREN_DISALLOW_INTERCEPT;
|
|
}
|
|
CharSequence drawerTitle = DrawerLayout.this.getDrawerTitle(DrawerLayout.this.getDrawerViewAbsoluteGravity(findVisibleDrawer));
|
|
if (drawerTitle == null) {
|
|
return DrawerLayout.CHILDREN_DISALLOW_INTERCEPT;
|
|
}
|
|
text.add(drawerTitle);
|
|
return DrawerLayout.CHILDREN_DISALLOW_INTERCEPT;
|
|
}
|
|
return super.dispatchPopulateAccessibilityEvent(view, accessibilityEvent);
|
|
}
|
|
|
|
@Override // androidx.core.view.AccessibilityDelegateCompat
|
|
public boolean onRequestSendAccessibilityEvent(ViewGroup viewGroup, View view, AccessibilityEvent accessibilityEvent) {
|
|
if (DrawerLayout.CAN_HIDE_DESCENDANTS || DrawerLayout.includeChildForAccessibility(view)) {
|
|
return super.onRequestSendAccessibilityEvent(viewGroup, view, accessibilityEvent);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private void addChildrenForAccessibility(AccessibilityNodeInfoCompat accessibilityNodeInfoCompat, ViewGroup viewGroup) {
|
|
int childCount = viewGroup.getChildCount();
|
|
for (int i = 0; i < childCount; i++) {
|
|
View childAt = viewGroup.getChildAt(i);
|
|
if (DrawerLayout.includeChildForAccessibility(childAt)) {
|
|
accessibilityNodeInfoCompat.addChild(childAt);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void copyNodeInfoNoChildren(AccessibilityNodeInfoCompat accessibilityNodeInfoCompat, AccessibilityNodeInfoCompat accessibilityNodeInfoCompat2) {
|
|
Rect rect = this.mTmpRect;
|
|
accessibilityNodeInfoCompat2.getBoundsInScreen(rect);
|
|
accessibilityNodeInfoCompat.setBoundsInScreen(rect);
|
|
accessibilityNodeInfoCompat.setVisibleToUser(accessibilityNodeInfoCompat2.isVisibleToUser());
|
|
accessibilityNodeInfoCompat.setPackageName(accessibilityNodeInfoCompat2.getPackageName());
|
|
accessibilityNodeInfoCompat.setClassName(accessibilityNodeInfoCompat2.getClassName());
|
|
accessibilityNodeInfoCompat.setContentDescription(accessibilityNodeInfoCompat2.getContentDescription());
|
|
accessibilityNodeInfoCompat.setEnabled(accessibilityNodeInfoCompat2.isEnabled());
|
|
accessibilityNodeInfoCompat.setFocused(accessibilityNodeInfoCompat2.isFocused());
|
|
accessibilityNodeInfoCompat.setAccessibilityFocused(accessibilityNodeInfoCompat2.isAccessibilityFocused());
|
|
accessibilityNodeInfoCompat.setSelected(accessibilityNodeInfoCompat2.isSelected());
|
|
accessibilityNodeInfoCompat.addAction(accessibilityNodeInfoCompat2.getActions());
|
|
}
|
|
}
|
|
|
|
static final class ChildAccessibilityDelegate extends AccessibilityDelegateCompat {
|
|
ChildAccessibilityDelegate() {
|
|
}
|
|
|
|
@Override // androidx.core.view.AccessibilityDelegateCompat
|
|
public void onInitializeAccessibilityNodeInfo(View view, AccessibilityNodeInfoCompat accessibilityNodeInfoCompat) {
|
|
super.onInitializeAccessibilityNodeInfo(view, accessibilityNodeInfoCompat);
|
|
if (DrawerLayout.includeChildForAccessibility(view)) {
|
|
return;
|
|
}
|
|
accessibilityNodeInfoCompat.setParent(null);
|
|
}
|
|
}
|
|
}
|