1690 lines
69 KiB
Java
1690 lines
69 KiB
Java
package androidx.drawerlayout.widget;
|
|
|
|
import android.annotation.SuppressLint;
|
|
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.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.ViewParent;
|
|
import android.view.WindowInsets;
|
|
import android.view.accessibility.AccessibilityEvent;
|
|
import androidx.annotation.ColorInt;
|
|
import androidx.annotation.DrawableRes;
|
|
import androidx.annotation.NonNull;
|
|
import androidx.annotation.Nullable;
|
|
import androidx.annotation.RestrictTo;
|
|
import androidx.constraintlayout.solver.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.customview.view.AbsSavedState;
|
|
import androidx.customview.widget.ViewDragHelper;
|
|
import c.d.b.a.a;
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
public class DrawerLayout extends ViewGroup {
|
|
private static final boolean ALLOW_EDGE_LOCK = false;
|
|
public static final boolean CAN_HIDE_DESCENDANTS = true;
|
|
private static final boolean CHILDREN_DISALLOW_INTERCEPT = true;
|
|
private static final int DEFAULT_SCRIM_COLOR = -1728053248;
|
|
private static final int DRAWER_ELEVATION = 10;
|
|
public static final int[] LAYOUT_ATTRS = {16842931};
|
|
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 = true;
|
|
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 int[] THEME_ATTRS = {16843828};
|
|
private static final float TOUCH_SLOP_SENSITIVITY = 1.0f;
|
|
private final ChildAccessibilityDelegate mChildAccessibilityDelegate;
|
|
private Rect mChildHitRect;
|
|
private Matrix mChildInvertedMatrix;
|
|
private boolean mChildrenCanceledTouch;
|
|
private boolean mDisallowInterceptRequested;
|
|
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;
|
|
@Nullable
|
|
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;
|
|
|
|
/* renamed from: androidx.drawerlayout.widget.DrawerLayout$1 reason: invalid class name */
|
|
public class AnonymousClass1 implements View.OnApplyWindowInsetsListener {
|
|
public AnonymousClass1() {
|
|
}
|
|
|
|
@Override // android.view.View.OnApplyWindowInsetsListener
|
|
public WindowInsets onApplyWindowInsets(View view, WindowInsets windowInsets) {
|
|
((DrawerLayout) view).setChildInsets(windowInsets, windowInsets.getSystemWindowInsetTop() > 0);
|
|
return windowInsets.consumeSystemWindowInsets();
|
|
}
|
|
}
|
|
|
|
public class AccessibilityDelegate extends AccessibilityDelegateCompat {
|
|
private final Rect mTmpRect = new Rect();
|
|
|
|
public AccessibilityDelegate() {
|
|
}
|
|
|
|
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.getBoundsInParent(rect);
|
|
accessibilityNodeInfoCompat.setBoundsInParent(rect);
|
|
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.setClickable(accessibilityNodeInfoCompat2.isClickable());
|
|
accessibilityNodeInfoCompat.setFocusable(accessibilityNodeInfoCompat2.isFocusable());
|
|
accessibilityNodeInfoCompat.setFocused(accessibilityNodeInfoCompat2.isFocused());
|
|
accessibilityNodeInfoCompat.setAccessibilityFocused(accessibilityNodeInfoCompat2.isAccessibilityFocused());
|
|
accessibilityNodeInfoCompat.setSelected(accessibilityNodeInfoCompat2.isSelected());
|
|
accessibilityNodeInfoCompat.setLongClickable(accessibilityNodeInfoCompat2.isLongClickable());
|
|
accessibilityNodeInfoCompat.addAction(accessibilityNodeInfoCompat2.getActions());
|
|
}
|
|
|
|
@Override // androidx.core.view.AccessibilityDelegateCompat
|
|
public boolean dispatchPopulateAccessibilityEvent(View view, AccessibilityEvent accessibilityEvent) {
|
|
CharSequence drawerTitle;
|
|
if (accessibilityEvent.getEventType() != 32) {
|
|
return super.dispatchPopulateAccessibilityEvent(view, accessibilityEvent);
|
|
}
|
|
List<CharSequence> text = accessibilityEvent.getText();
|
|
View findVisibleDrawer = DrawerLayout.this.findVisibleDrawer();
|
|
if (findVisibleDrawer == null || (drawerTitle = DrawerLayout.this.getDrawerTitle(DrawerLayout.this.getDrawerViewAbsoluteGravity(findVisibleDrawer))) == null) {
|
|
return true;
|
|
}
|
|
text.add(drawerTitle);
|
|
return true;
|
|
}
|
|
|
|
@Override // androidx.core.view.AccessibilityDelegateCompat
|
|
public void onInitializeAccessibilityEvent(View view, AccessibilityEvent accessibilityEvent) {
|
|
super.onInitializeAccessibilityEvent(view, accessibilityEvent);
|
|
accessibilityEvent.setClassName(DrawerLayout.class.getName());
|
|
}
|
|
|
|
@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);
|
|
ViewParent parentForAccessibility = ViewCompat.getParentForAccessibility(view);
|
|
if (parentForAccessibility instanceof View) {
|
|
accessibilityNodeInfoCompat.setParent((View) parentForAccessibility);
|
|
}
|
|
copyNodeInfoNoChildren(accessibilityNodeInfoCompat, obtain);
|
|
obtain.recycle();
|
|
addChildrenForAccessibility(accessibilityNodeInfoCompat, (ViewGroup) view);
|
|
}
|
|
accessibilityNodeInfoCompat.setClassName(DrawerLayout.class.getName());
|
|
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 boolean onRequestSendAccessibilityEvent(ViewGroup viewGroup, View view, AccessibilityEvent accessibilityEvent) {
|
|
if (DrawerLayout.CAN_HIDE_DESCENDANTS || DrawerLayout.includeChildForAccessibility(view)) {
|
|
return super.onRequestSendAccessibilityEvent(viewGroup, view, accessibilityEvent);
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public static final class ChildAccessibilityDelegate extends AccessibilityDelegateCompat {
|
|
@Override // androidx.core.view.AccessibilityDelegateCompat
|
|
public void onInitializeAccessibilityNodeInfo(View view, AccessibilityNodeInfoCompat accessibilityNodeInfoCompat) {
|
|
super.onInitializeAccessibilityNodeInfo(view, accessibilityNodeInfoCompat);
|
|
if (!DrawerLayout.includeChildForAccessibility(view)) {
|
|
accessibilityNodeInfoCompat.setParent(null);
|
|
}
|
|
}
|
|
}
|
|
|
|
public interface DrawerListener {
|
|
void onDrawerClosed(@NonNull View view);
|
|
|
|
void onDrawerOpened(@NonNull View view);
|
|
|
|
void onDrawerSlide(@NonNull View view, float f);
|
|
|
|
void onDrawerStateChanged(int i);
|
|
}
|
|
|
|
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;
|
|
public boolean isPeeking;
|
|
public float onScreen;
|
|
public int openState;
|
|
|
|
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(@NonNull Context context, @Nullable 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(@NonNull ViewGroup.LayoutParams layoutParams) {
|
|
super(layoutParams);
|
|
this.gravity = 0;
|
|
}
|
|
|
|
public LayoutParams(@NonNull ViewGroup.MarginLayoutParams marginLayoutParams) {
|
|
super(marginLayoutParams);
|
|
this.gravity = 0;
|
|
}
|
|
|
|
public LayoutParams(@NonNull LayoutParams layoutParams) {
|
|
super((ViewGroup.MarginLayoutParams) layoutParams);
|
|
this.gravity = 0;
|
|
this.gravity = layoutParams.gravity;
|
|
}
|
|
}
|
|
|
|
public static class SavedState extends AbsSavedState {
|
|
public static final Parcelable.Creator<SavedState> CREATOR = new AnonymousClass1();
|
|
public int lockModeEnd;
|
|
public int lockModeLeft;
|
|
public int lockModeRight;
|
|
public int lockModeStart;
|
|
public int openDrawerGravity = 0;
|
|
|
|
/* renamed from: androidx.drawerlayout.widget.DrawerLayout$SavedState$1 reason: invalid class name */
|
|
public static class AnonymousClass1 implements Parcelable.ClassLoaderCreator<SavedState> {
|
|
@Override // android.os.Parcelable.Creator
|
|
public SavedState createFromParcel(Parcel parcel) {
|
|
return new SavedState(parcel, null);
|
|
}
|
|
|
|
@Override // android.os.Parcelable.ClassLoaderCreator
|
|
public SavedState createFromParcel(Parcel parcel, ClassLoader classLoader) {
|
|
return new SavedState(parcel, classLoader);
|
|
}
|
|
|
|
@Override // android.os.Parcelable.Creator
|
|
public SavedState[] newArray(int i) {
|
|
return new SavedState[i];
|
|
}
|
|
}
|
|
|
|
public SavedState(@NonNull Parcel parcel, @Nullable ClassLoader classLoader) {
|
|
super(parcel, classLoader);
|
|
this.openDrawerGravity = parcel.readInt();
|
|
this.lockModeLeft = parcel.readInt();
|
|
this.lockModeRight = parcel.readInt();
|
|
this.lockModeStart = parcel.readInt();
|
|
this.lockModeEnd = parcel.readInt();
|
|
}
|
|
|
|
public SavedState(@NonNull Parcelable parcelable) {
|
|
super(parcelable);
|
|
}
|
|
|
|
@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);
|
|
}
|
|
}
|
|
|
|
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) {
|
|
}
|
|
}
|
|
|
|
public class ViewDragCallback extends ViewDragHelper.Callback {
|
|
private final int mAbsGravity;
|
|
private ViewDragHelper mDragger;
|
|
private final Runnable mPeekRunnable = new AnonymousClass1();
|
|
|
|
/* renamed from: androidx.drawerlayout.widget.DrawerLayout$ViewDragCallback$1 reason: invalid class name */
|
|
public class AnonymousClass1 implements Runnable {
|
|
public AnonymousClass1() {
|
|
}
|
|
|
|
@Override // java.lang.Runnable
|
|
public void run() {
|
|
ViewDragCallback.this.peekDrawer();
|
|
}
|
|
}
|
|
|
|
public ViewDragCallback(int i) {
|
|
this.mAbsGravity = i;
|
|
}
|
|
|
|
private void closeOtherDrawer() {
|
|
int i = 3;
|
|
if (this.mAbsGravity == 3) {
|
|
i = 5;
|
|
}
|
|
View findDrawerWithGravity = DrawerLayout.this.findDrawerWithGravity(i);
|
|
if (findDrawerWithGravity != null) {
|
|
DrawerLayout.this.closeDrawer(findDrawerWithGravity);
|
|
}
|
|
}
|
|
|
|
@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();
|
|
}
|
|
|
|
@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 void onEdgeDragStarted(int i, int i2) {
|
|
View findDrawerWithGravity = (i & 1) == 1 ? DrawerLayout.this.findDrawerWithGravity(3) : DrawerLayout.this.findDrawerWithGravity(5);
|
|
if (findDrawerWithGravity != null && DrawerLayout.this.getDrawerLockMode(findDrawerWithGravity) == 0) {
|
|
this.mDragger.captureChildView(findDrawerWithGravity, i2);
|
|
}
|
|
}
|
|
|
|
@Override // androidx.customview.widget.ViewDragHelper.Callback
|
|
public boolean onEdgeLock(int i) {
|
|
return false;
|
|
}
|
|
|
|
@Override // androidx.customview.widget.ViewDragHelper.Callback
|
|
public void onEdgeTouched(int i, int i2) {
|
|
DrawerLayout.this.postDelayed(this.mPeekRunnable, 160);
|
|
}
|
|
|
|
@Override // androidx.customview.widget.ViewDragHelper.Callback
|
|
public void onViewCaptured(View view, int i) {
|
|
((LayoutParams) view.getLayoutParams()).isPeeking = false;
|
|
closeOtherDrawer();
|
|
}
|
|
|
|
@Override // androidx.customview.widget.ViewDragHelper.Callback
|
|
public void onViewDragStateChanged(int i) {
|
|
DrawerLayout.this.updateDrawerState(this.mAbsGravity, i, this.mDragger.getCapturedView());
|
|
}
|
|
|
|
@Override // androidx.customview.widget.ViewDragHelper.Callback
|
|
public void onViewPositionChanged(View view, int i, int i2, int i3, int i4) {
|
|
int width = view.getWidth();
|
|
float width2 = (DrawerLayout.this.checkDrawerViewAbsoluteGravity(view, 3) ? (float) (i + width) : (float) (DrawerLayout.this.getWidth() - i)) / ((float) width);
|
|
DrawerLayout.this.setDrawerViewOffset(view, width2);
|
|
view.setVisibility(width2 == 0.0f ? 4 : 0);
|
|
DrawerLayout.this.invalidate();
|
|
}
|
|
|
|
@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)) {
|
|
int i2 = (f > 0.0f ? 1 : (f == 0.0f ? 0 : -1));
|
|
i = (i2 > 0 || (i2 == 0 && 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();
|
|
}
|
|
|
|
public void peekDrawer() {
|
|
View view;
|
|
int i;
|
|
int edgeSize = this.mDragger.getEdgeSize();
|
|
int i2 = 0;
|
|
boolean z2 = this.mAbsGravity == 3;
|
|
if (z2) {
|
|
view = DrawerLayout.this.findDrawerWithGravity(3);
|
|
if (view != null) {
|
|
i2 = -view.getWidth();
|
|
}
|
|
i = i2 + edgeSize;
|
|
} else {
|
|
view = DrawerLayout.this.findDrawerWithGravity(5);
|
|
i = DrawerLayout.this.getWidth() - edgeSize;
|
|
}
|
|
if (view == null) {
|
|
return;
|
|
}
|
|
if (((z2 && view.getLeft() < i) || (!z2 && view.getLeft() > i)) && DrawerLayout.this.getDrawerLockMode(view) == 0) {
|
|
this.mDragger.smoothSlideViewTo(view, i, view.getTop());
|
|
((LayoutParams) view.getLayoutParams()).isPeeking = true;
|
|
DrawerLayout.this.invalidate();
|
|
closeOtherDrawer();
|
|
DrawerLayout.this.cancelChildViewTouch();
|
|
}
|
|
}
|
|
|
|
public void removeCallbacks() {
|
|
DrawerLayout.this.removeCallbacks(this.mPeekRunnable);
|
|
}
|
|
|
|
public void setDragger(ViewDragHelper viewDragHelper) {
|
|
this.mDragger = viewDragHelper;
|
|
}
|
|
|
|
@Override // androidx.customview.widget.ViewDragHelper.Callback
|
|
public boolean tryCaptureView(View view, int i) {
|
|
return DrawerLayout.this.isDrawerView(view) && DrawerLayout.this.checkDrawerViewAbsoluteGravity(view, this.mAbsGravity) && DrawerLayout.this.getDrawerLockMode(view) == 0;
|
|
}
|
|
}
|
|
|
|
public DrawerLayout(@NonNull Context context) {
|
|
this(context, null);
|
|
}
|
|
|
|
public DrawerLayout(@NonNull Context context, @Nullable AttributeSet attributeSet) {
|
|
this(context, attributeSet, 0);
|
|
}
|
|
|
|
public DrawerLayout(@NonNull Context context, @Nullable AttributeSet attributeSet, int i) {
|
|
super(context, attributeSet, i);
|
|
this.mChildAccessibilityDelegate = new ChildAccessibilityDelegate();
|
|
this.mScrimColor = DEFAULT_SCRIM_COLOR;
|
|
this.mScrimPaint = new Paint();
|
|
this.mFirstLayout = true;
|
|
this.mLockModeLeft = 3;
|
|
this.mLockModeRight = 3;
|
|
this.mLockModeStart = 3;
|
|
this.mLockModeEnd = 3;
|
|
this.mShadowStart = null;
|
|
this.mShadowEnd = null;
|
|
this.mShadowLeft = null;
|
|
this.mShadowRight = null;
|
|
setDescendantFocusability(262144);
|
|
float f = getResources().getDisplayMetrics().density;
|
|
this.mMinDrawerMargin = (int) ((64.0f * f) + 0.5f);
|
|
float f2 = 400.0f * f;
|
|
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(true);
|
|
ViewCompat.setImportantForAccessibility(this, 1);
|
|
ViewCompat.setAccessibilityDelegate(this, new AccessibilityDelegate());
|
|
setMotionEventSplittingEnabled(false);
|
|
if (ViewCompat.getFitsSystemWindows(this)) {
|
|
setOnApplyWindowInsetsListener(new AnonymousClass1());
|
|
setSystemUiVisibility(1280);
|
|
TypedArray obtainStyledAttributes = context.obtainStyledAttributes(THEME_ATTRS);
|
|
try {
|
|
this.mStatusBarBackground = obtainStyledAttributes.getDrawable(0);
|
|
} finally {
|
|
obtainStyledAttributes.recycle();
|
|
}
|
|
}
|
|
this.mDrawerElevation = f * 10.0f;
|
|
this.mNonDrawerViews = new ArrayList<>();
|
|
}
|
|
|
|
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 = (float) (getScrollX() - view.getLeft());
|
|
float scrollY = (float) (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) {
|
|
MotionEvent obtain = MotionEvent.obtain(motionEvent);
|
|
obtain.offsetLocation((float) (getScrollX() - view.getLeft()), (float) (getScrollY() - view.getTop()));
|
|
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;
|
|
}
|
|
|
|
public static String gravityToString(int i) {
|
|
return (i & 3) == 3 ? "LEFT" : (i & 5) == 5 ? "RIGHT" : Integer.toHexString(i);
|
|
}
|
|
|
|
private static boolean hasOpaqueBackground(View view) {
|
|
Drawable background = view.getBackground();
|
|
return background != null && background.getOpacity() == -1;
|
|
}
|
|
|
|
private boolean hasPeekingDrawer() {
|
|
int childCount = getChildCount();
|
|
for (int i = 0; i < childCount; i++) {
|
|
if (((LayoutParams) getChildAt(i).getLayoutParams()).isPeeking) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private boolean hasVisibleDrawer() {
|
|
return findVisibleDrawer() != null;
|
|
}
|
|
|
|
public static boolean includeChildForAccessibility(View view) {
|
|
return (ViewCompat.getImportantForAccessibility(view) == 4 || ViewCompat.getImportantForAccessibility(view) == 2) ? false : true;
|
|
}
|
|
|
|
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 mirror(Drawable drawable, int i) {
|
|
if (drawable == null || !DrawableCompat.isAutoMirrored(drawable)) {
|
|
return false;
|
|
}
|
|
DrawableCompat.setLayoutDirection(drawable, i);
|
|
return true;
|
|
}
|
|
|
|
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 resolveShadowDrawables() {
|
|
if (!SET_DRAWER_SHADOW_FROM_ELEVATION) {
|
|
this.mShadowLeftResolved = resolveLeftShadow();
|
|
this.mShadowRightResolved = resolveRightShadow();
|
|
}
|
|
}
|
|
|
|
private void updateChildrenImportantForAccessibility(View view, boolean z2) {
|
|
int childCount = getChildCount();
|
|
for (int i = 0; i < childCount; i++) {
|
|
View childAt = getChildAt(i);
|
|
if ((z2 || isDrawerView(childAt)) && (!z2 || childAt != view)) {
|
|
ViewCompat.setImportantForAccessibility(childAt, 4);
|
|
} else {
|
|
ViewCompat.setImportantForAccessibility(childAt, 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void addDrawerListener(@NonNull DrawerListener drawerListener) {
|
|
if (drawerListener != null) {
|
|
if (this.mListeners == null) {
|
|
this.mListeners = new ArrayList();
|
|
}
|
|
this.mListeners.add(drawerListener);
|
|
}
|
|
}
|
|
|
|
@Override // android.view.ViewGroup, android.view.View
|
|
public void addFocusables(ArrayList<View> arrayList, int i, int i2) {
|
|
if (getDescendantFocusability() != 393216) {
|
|
int childCount = getChildCount();
|
|
boolean z2 = false;
|
|
for (int i3 = 0; i3 < childCount; i3++) {
|
|
View childAt = getChildAt(i3);
|
|
if (!isDrawerView(childAt)) {
|
|
this.mNonDrawerViews.add(childAt);
|
|
} else if (isDrawerOpen(childAt)) {
|
|
childAt.addFocusables(arrayList, i, i2);
|
|
z2 = true;
|
|
}
|
|
}
|
|
if (!z2) {
|
|
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();
|
|
}
|
|
}
|
|
|
|
@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) {
|
|
ViewCompat.setAccessibilityDelegate(view, this.mChildAccessibilityDelegate);
|
|
}
|
|
}
|
|
|
|
public void cancelChildViewTouch() {
|
|
if (!this.mChildrenCanceledTouch) {
|
|
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 = true;
|
|
}
|
|
}
|
|
|
|
public boolean checkDrawerViewAbsoluteGravity(View view, int i) {
|
|
return (getDrawerViewAbsoluteGravity(view) & i) == i;
|
|
}
|
|
|
|
@Override // android.view.ViewGroup
|
|
public boolean checkLayoutParams(ViewGroup.LayoutParams layoutParams) {
|
|
return (layoutParams instanceof LayoutParams) && super.checkLayoutParams(layoutParams);
|
|
}
|
|
|
|
public void closeDrawer(int i) {
|
|
closeDrawer(i, true);
|
|
}
|
|
|
|
public void closeDrawer(int i, boolean z2) {
|
|
View findDrawerWithGravity = findDrawerWithGravity(i);
|
|
if (findDrawerWithGravity != null) {
|
|
closeDrawer(findDrawerWithGravity, z2);
|
|
return;
|
|
}
|
|
StringBuilder P = a.P("No drawer view found with gravity ");
|
|
P.append(gravityToString(i));
|
|
throw new IllegalArgumentException(P.toString());
|
|
}
|
|
|
|
public void closeDrawer(@NonNull View view) {
|
|
closeDrawer(view, true);
|
|
}
|
|
|
|
public void closeDrawer(@NonNull View view, boolean z2) {
|
|
if (isDrawerView(view)) {
|
|
LayoutParams layoutParams = (LayoutParams) view.getLayoutParams();
|
|
if (this.mFirstLayout) {
|
|
layoutParams.onScreen = 0.0f;
|
|
layoutParams.openState = 0;
|
|
} else if (z2) {
|
|
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(layoutParams.gravity, 0, view);
|
|
view.setVisibility(4);
|
|
}
|
|
invalidate();
|
|
return;
|
|
}
|
|
throw new IllegalArgumentException("View " + view + " is not a sliding drawer");
|
|
}
|
|
|
|
public void closeDrawers() {
|
|
closeDrawers(false);
|
|
}
|
|
|
|
public void closeDrawers(boolean z2) {
|
|
int childCount = getChildCount();
|
|
boolean z3 = false;
|
|
for (int i = 0; i < childCount; i++) {
|
|
View childAt = getChildAt(i);
|
|
LayoutParams layoutParams = (LayoutParams) childAt.getLayoutParams();
|
|
if (isDrawerView(childAt) && (!z2 || layoutParams.isPeeking)) {
|
|
z3 |= checkDrawerViewAbsoluteGravity(childAt, 3) ? this.mLeftDragger.smoothSlideViewTo(childAt, -childAt.getWidth(), childAt.getTop()) : this.mRightDragger.smoothSlideViewTo(childAt, getWidth(), childAt.getTop());
|
|
layoutParams.isPeeking = false;
|
|
}
|
|
}
|
|
this.mLeftCallback.removeCallbacks();
|
|
this.mRightCallback.removeCallbacks();
|
|
if (z3) {
|
|
invalidate();
|
|
}
|
|
}
|
|
|
|
@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(true);
|
|
boolean continueSettling2 = this.mRightDragger.continueSettling(true);
|
|
if (continueSettling || continueSettling2) {
|
|
ViewCompat.postInvalidateOnAnimation(this);
|
|
}
|
|
}
|
|
|
|
@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 x2 = motionEvent.getX();
|
|
float y2 = motionEvent.getY();
|
|
for (int i = childCount - 1; i >= 0; i--) {
|
|
View childAt = getChildAt(i);
|
|
if (isInBoundsOfChild(x2, y2, childAt) && !isContentView(childAt) && dispatchTransformedGenericPointerEvent(motionEvent, childAt)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public 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);
|
|
if (hasWindowFocus() && (rootView = getRootView()) != null) {
|
|
rootView.sendAccessibilityEvent(32);
|
|
}
|
|
}
|
|
}
|
|
|
|
public 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, true);
|
|
if (hasWindowFocus()) {
|
|
sendAccessibilityEvent(32);
|
|
}
|
|
}
|
|
}
|
|
|
|
public 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);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override // android.view.ViewGroup
|
|
public 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) {
|
|
int i4 = this.mScrimColor;
|
|
this.mScrimPaint.setColor((i4 & ViewCompat.MEASURED_SIZE_MASK) | (((int) (((float) ((-16777216 & i4) >>> 24)) * f)) << 24));
|
|
canvas.drawRect((float) i, 0.0f, (float) width, (float) 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(((float) right2) / ((float) 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(((float) (getWidth() - left2)) / ((float) 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;
|
|
}
|
|
|
|
public 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;
|
|
}
|
|
|
|
public 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;
|
|
}
|
|
|
|
public 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;
|
|
}
|
|
|
|
@Override // android.view.ViewGroup
|
|
public ViewGroup.LayoutParams generateDefaultLayoutParams() {
|
|
return new LayoutParams(-1, -1);
|
|
}
|
|
|
|
@Override // android.view.ViewGroup
|
|
public ViewGroup.LayoutParams generateLayoutParams(AttributeSet attributeSet) {
|
|
return new LayoutParams(getContext(), attributeSet);
|
|
}
|
|
|
|
@Override // android.view.ViewGroup
|
|
public ViewGroup.LayoutParams generateLayoutParams(ViewGroup.LayoutParams layoutParams) {
|
|
return layoutParams instanceof LayoutParams ? new LayoutParams((LayoutParams) layoutParams) : layoutParams instanceof ViewGroup.MarginLayoutParams ? new LayoutParams((ViewGroup.MarginLayoutParams) layoutParams) : new LayoutParams(layoutParams);
|
|
}
|
|
|
|
public float getDrawerElevation() {
|
|
if (SET_DRAWER_SHADOW_FROM_ELEVATION) {
|
|
return this.mDrawerElevation;
|
|
}
|
|
return 0.0f;
|
|
}
|
|
|
|
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;
|
|
} else 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;
|
|
} else 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;
|
|
} else if (i != 8388613) {
|
|
return 0;
|
|
} else {
|
|
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(@NonNull View view) {
|
|
if (isDrawerView(view)) {
|
|
return getDrawerLockMode(((LayoutParams) view.getLayoutParams()).gravity);
|
|
}
|
|
throw new IllegalArgumentException("View " + view + " is not a drawer");
|
|
}
|
|
|
|
@Nullable
|
|
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;
|
|
}
|
|
|
|
public int getDrawerViewAbsoluteGravity(View view) {
|
|
return GravityCompat.getAbsoluteGravity(((LayoutParams) view.getLayoutParams()).gravity, ViewCompat.getLayoutDirection(this));
|
|
}
|
|
|
|
public float getDrawerViewOffset(View view) {
|
|
return ((LayoutParams) view.getLayoutParams()).onScreen;
|
|
}
|
|
|
|
@Nullable
|
|
public Drawable getStatusBarBackgroundDrawable() {
|
|
return this.mStatusBarBackground;
|
|
}
|
|
|
|
public boolean isContentView(View view) {
|
|
return ((LayoutParams) view.getLayoutParams()).gravity == 0;
|
|
}
|
|
|
|
public boolean isDrawerOpen(int i) {
|
|
View findDrawerWithGravity = findDrawerWithGravity(i);
|
|
if (findDrawerWithGravity != null) {
|
|
return isDrawerOpen(findDrawerWithGravity);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean isDrawerOpen(@NonNull View view) {
|
|
if (isDrawerView(view)) {
|
|
return (((LayoutParams) view.getLayoutParams()).openState & 1) == 1;
|
|
}
|
|
throw new IllegalArgumentException("View " + view + " is not a drawer");
|
|
}
|
|
|
|
public boolean isDrawerView(View view) {
|
|
int absoluteGravity = GravityCompat.getAbsoluteGravity(((LayoutParams) view.getLayoutParams()).gravity, ViewCompat.getLayoutDirection(view));
|
|
return ((absoluteGravity & 3) == 0 && (absoluteGravity & 5) == 0) ? false : true;
|
|
}
|
|
|
|
public boolean isDrawerVisible(int i) {
|
|
View findDrawerWithGravity = findDrawerWithGravity(i);
|
|
if (findDrawerWithGravity != null) {
|
|
return isDrawerVisible(findDrawerWithGravity);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean isDrawerVisible(@NonNull View view) {
|
|
if (isDrawerView(view)) {
|
|
return ((LayoutParams) view.getLayoutParams()).onScreen > 0.0f;
|
|
}
|
|
throw new IllegalArgumentException("View " + view + " is not a drawer");
|
|
}
|
|
|
|
public void moveDrawerToOffset(View view, float f) {
|
|
float drawerViewOffset = getDrawerViewOffset(view);
|
|
float width = (float) view.getWidth();
|
|
int i = ((int) (width * f)) - ((int) (drawerViewOffset * width));
|
|
if (!checkDrawerViewAbsoluteGravity(view, 3)) {
|
|
i = -i;
|
|
}
|
|
view.offsetLeftAndRight(i);
|
|
setDrawerViewOffset(view, f);
|
|
}
|
|
|
|
@Override // android.view.ViewGroup, android.view.View
|
|
public void onAttachedToWindow() {
|
|
super.onAttachedToWindow();
|
|
this.mFirstLayout = true;
|
|
}
|
|
|
|
@Override // android.view.ViewGroup, android.view.View
|
|
public void onDetachedFromWindow() {
|
|
super.onDetachedFromWindow();
|
|
this.mFirstLayout = true;
|
|
}
|
|
|
|
@Override // android.view.View
|
|
public void onDraw(Canvas canvas) {
|
|
super.onDraw(canvas);
|
|
if (this.mDrawStatusBarBackground && this.mStatusBarBackground != null) {
|
|
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);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* JADX WARNING: Code restructure failed: missing block: B:5:0x001b, code lost:
|
|
if (r0 != 3) goto L_0x0038;
|
|
*/
|
|
@Override // android.view.ViewGroup
|
|
public boolean onInterceptTouchEvent(MotionEvent motionEvent) {
|
|
boolean z2;
|
|
View findTopChildUnder;
|
|
int actionMasked = motionEvent.getActionMasked();
|
|
boolean shouldInterceptTouchEvent = this.mLeftDragger.shouldInterceptTouchEvent(motionEvent) | this.mRightDragger.shouldInterceptTouchEvent(motionEvent);
|
|
if (actionMasked != 0) {
|
|
if (actionMasked != 1) {
|
|
if (actionMasked == 2) {
|
|
if (this.mLeftDragger.checkTouchSlop(3)) {
|
|
this.mLeftCallback.removeCallbacks();
|
|
this.mRightCallback.removeCallbacks();
|
|
}
|
|
}
|
|
z2 = false;
|
|
}
|
|
closeDrawers(true);
|
|
this.mDisallowInterceptRequested = false;
|
|
this.mChildrenCanceledTouch = false;
|
|
z2 = false;
|
|
} else {
|
|
float x2 = motionEvent.getX();
|
|
float y2 = motionEvent.getY();
|
|
this.mInitialMotionX = x2;
|
|
this.mInitialMotionY = y2;
|
|
z2 = this.mScrimOpacity > 0.0f && (findTopChildUnder = this.mLeftDragger.findTopChildUnder((int) x2, (int) y2)) != null && isContentView(findTopChildUnder);
|
|
this.mDisallowInterceptRequested = false;
|
|
this.mChildrenCanceledTouch = false;
|
|
}
|
|
return shouldInterceptTouchEvent || z2 || hasPeekingDrawer() || this.mChildrenCanceledTouch;
|
|
}
|
|
|
|
@Override // android.view.KeyEvent.Callback, android.view.View
|
|
public boolean onKeyDown(int i, KeyEvent keyEvent) {
|
|
if (i != 4 || !hasVisibleDrawer()) {
|
|
return super.onKeyDown(i, keyEvent);
|
|
}
|
|
keyEvent.startTracking();
|
|
return true;
|
|
}
|
|
|
|
@Override // android.view.KeyEvent.Callback, android.view.View
|
|
public boolean onKeyUp(int i, KeyEvent keyEvent) {
|
|
if (i != 4) {
|
|
return super.onKeyUp(i, keyEvent);
|
|
}
|
|
View findVisibleDrawer = findVisibleDrawer();
|
|
if (findVisibleDrawer != null && getDrawerLockMode(findVisibleDrawer) == 0) {
|
|
closeDrawers();
|
|
}
|
|
return findVisibleDrawer != null;
|
|
}
|
|
|
|
@Override // android.view.ViewGroup, android.view.View
|
|
public void onLayout(boolean z2, int i, int i2, int i3, int i4) {
|
|
float f;
|
|
int i5;
|
|
this.mInLayout = true;
|
|
int i6 = i3 - i;
|
|
int childCount = getChildCount();
|
|
for (int i7 = 0; i7 < childCount; i7++) {
|
|
View childAt = getChildAt(i7);
|
|
if (childAt.getVisibility() != 8) {
|
|
LayoutParams layoutParams = (LayoutParams) childAt.getLayoutParams();
|
|
if (isContentView(childAt)) {
|
|
int i8 = ((ViewGroup.MarginLayoutParams) layoutParams).leftMargin;
|
|
childAt.layout(i8, ((ViewGroup.MarginLayoutParams) layoutParams).topMargin, childAt.getMeasuredWidth() + i8, childAt.getMeasuredHeight() + ((ViewGroup.MarginLayoutParams) layoutParams).topMargin);
|
|
} else {
|
|
int measuredWidth = childAt.getMeasuredWidth();
|
|
int measuredHeight = childAt.getMeasuredHeight();
|
|
if (checkDrawerViewAbsoluteGravity(childAt, 3)) {
|
|
float f2 = (float) measuredWidth;
|
|
i5 = (-measuredWidth) + ((int) (layoutParams.onScreen * f2));
|
|
f = ((float) (measuredWidth + i5)) / f2;
|
|
} else {
|
|
float f3 = (float) measuredWidth;
|
|
int i9 = i6 - ((int) (layoutParams.onScreen * f3));
|
|
f = ((float) (i6 - i9)) / f3;
|
|
i5 = i9;
|
|
}
|
|
boolean z3 = f != layoutParams.onScreen;
|
|
int i10 = layoutParams.gravity & 112;
|
|
if (i10 == 16) {
|
|
int i11 = i4 - i2;
|
|
int i12 = (i11 - measuredHeight) / 2;
|
|
int i13 = ((ViewGroup.MarginLayoutParams) layoutParams).topMargin;
|
|
if (i12 < i13) {
|
|
i12 = i13;
|
|
} else {
|
|
int i14 = i12 + measuredHeight;
|
|
int i15 = ((ViewGroup.MarginLayoutParams) layoutParams).bottomMargin;
|
|
if (i14 > i11 - i15) {
|
|
i12 = (i11 - i15) - measuredHeight;
|
|
}
|
|
}
|
|
childAt.layout(i5, i12, measuredWidth + i5, measuredHeight + i12);
|
|
} else if (i10 != 80) {
|
|
int i16 = ((ViewGroup.MarginLayoutParams) layoutParams).topMargin;
|
|
childAt.layout(i5, i16, measuredWidth + i5, measuredHeight + i16);
|
|
} else {
|
|
int i17 = i4 - i2;
|
|
childAt.layout(i5, (i17 - ((ViewGroup.MarginLayoutParams) layoutParams).bottomMargin) - childAt.getMeasuredHeight(), measuredWidth + i5, i17 - ((ViewGroup.MarginLayoutParams) layoutParams).bottomMargin);
|
|
}
|
|
if (z3) {
|
|
setDrawerViewOffset(childAt, f);
|
|
}
|
|
int i18 = layoutParams.onScreen > 0.0f ? 0 : 4;
|
|
if (childAt.getVisibility() != i18) {
|
|
childAt.setVisibility(i18);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
this.mInLayout = false;
|
|
this.mFirstLayout = false;
|
|
}
|
|
|
|
@Override // android.view.View
|
|
@SuppressLint({"WrongConstant"})
|
|
public 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()) {
|
|
if (mode != Integer.MIN_VALUE && mode == 0) {
|
|
size = 300;
|
|
}
|
|
if (mode2 != Integer.MIN_VALUE && mode2 == 0) {
|
|
size2 = 300;
|
|
}
|
|
} else {
|
|
throw new IllegalArgumentException("DrawerLayout must be measured with MeasureSpec.EXACTLY.");
|
|
}
|
|
}
|
|
setMeasuredDimension(size, size2);
|
|
int i3 = 0;
|
|
boolean z2 = this.mLastInsets != null && ViewCompat.getFitsSystemWindows(this);
|
|
int layoutDirection = ViewCompat.getLayoutDirection(this);
|
|
int childCount = getChildCount();
|
|
int i4 = 0;
|
|
boolean z3 = false;
|
|
boolean z4 = false;
|
|
while (i4 < childCount) {
|
|
View childAt = getChildAt(i4);
|
|
if (childAt.getVisibility() != 8) {
|
|
LayoutParams layoutParams = (LayoutParams) childAt.getLayoutParams();
|
|
if (z2) {
|
|
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(), i3, windowInsets.getSystemWindowInsetBottom());
|
|
} else if (absoluteGravity == 5) {
|
|
windowInsets = windowInsets.replaceSystemWindowInsets(i3, 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(), i3, windowInsets2.getSystemWindowInsetBottom());
|
|
} else if (absoluteGravity == 5) {
|
|
windowInsets2 = windowInsets2.replaceSystemWindowInsets(i3, windowInsets2.getSystemWindowInsetTop(), windowInsets2.getSystemWindowInsetRight(), windowInsets2.getSystemWindowInsetBottom());
|
|
}
|
|
((ViewGroup.MarginLayoutParams) layoutParams).leftMargin = windowInsets2.getSystemWindowInsetLeft();
|
|
((ViewGroup.MarginLayoutParams) layoutParams).topMargin = windowInsets2.getSystemWindowInsetTop();
|
|
((ViewGroup.MarginLayoutParams) layoutParams).rightMargin = windowInsets2.getSystemWindowInsetRight();
|
|
((ViewGroup.MarginLayoutParams) layoutParams).bottomMargin = windowInsets2.getSystemWindowInsetBottom();
|
|
}
|
|
}
|
|
if (isContentView(childAt)) {
|
|
childAt.measure(View.MeasureSpec.makeMeasureSpec((size - ((ViewGroup.MarginLayoutParams) layoutParams).leftMargin) - ((ViewGroup.MarginLayoutParams) layoutParams).rightMargin, BasicMeasure.EXACTLY), View.MeasureSpec.makeMeasureSpec((size2 - ((ViewGroup.MarginLayoutParams) layoutParams).topMargin) - ((ViewGroup.MarginLayoutParams) 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 z5 = drawerViewAbsoluteGravity == 3;
|
|
if ((!z5 || !z3) && (z5 || !z4)) {
|
|
if (z5) {
|
|
z3 = true;
|
|
} else {
|
|
z4 = true;
|
|
}
|
|
childAt.measure(ViewGroup.getChildMeasureSpec(i, this.mMinDrawerMargin + ((ViewGroup.MarginLayoutParams) layoutParams).leftMargin + ((ViewGroup.MarginLayoutParams) layoutParams).rightMargin, ((ViewGroup.MarginLayoutParams) layoutParams).width), ViewGroup.getChildMeasureSpec(i2, ((ViewGroup.MarginLayoutParams) layoutParams).topMargin + ((ViewGroup.MarginLayoutParams) layoutParams).bottomMargin, ((ViewGroup.MarginLayoutParams) layoutParams).height));
|
|
i4++;
|
|
i3 = 0;
|
|
} else {
|
|
StringBuilder P = a.P("Child drawer has absolute gravity ");
|
|
P.append(gravityToString(drawerViewAbsoluteGravity));
|
|
P.append(" but this ");
|
|
P.append(TAG);
|
|
P.append(" already has a ");
|
|
P.append("drawer view along that edge");
|
|
throw new IllegalStateException(P.toString());
|
|
}
|
|
} else {
|
|
throw new IllegalStateException("Child " + childAt + " at index " + i4 + " does not have a valid layout_gravity - must be Gravity.LEFT, Gravity.RIGHT or Gravity.NO_GRAVITY");
|
|
}
|
|
}
|
|
i4++;
|
|
i3 = 0;
|
|
}
|
|
}
|
|
|
|
@Override // android.view.View
|
|
public void onRestoreInstanceState(Parcelable parcelable) {
|
|
View findDrawerWithGravity;
|
|
if (!(parcelable instanceof SavedState)) {
|
|
super.onRestoreInstanceState(parcelable);
|
|
return;
|
|
}
|
|
SavedState savedState = (SavedState) parcelable;
|
|
super.onRestoreInstanceState(savedState.getSuperState());
|
|
int i = savedState.openDrawerGravity;
|
|
if (!(i == 0 || (findDrawerWithGravity = findDrawerWithGravity(i)) == null)) {
|
|
openDrawer(findDrawerWithGravity);
|
|
}
|
|
int i2 = savedState.lockModeLeft;
|
|
if (i2 != 3) {
|
|
setDrawerLockMode(i2, 3);
|
|
}
|
|
int i3 = savedState.lockModeRight;
|
|
if (i3 != 3) {
|
|
setDrawerLockMode(i3, 5);
|
|
}
|
|
int i4 = savedState.lockModeStart;
|
|
if (i4 != 3) {
|
|
setDrawerLockMode(i4, GravityCompat.START);
|
|
}
|
|
int i5 = savedState.lockModeEnd;
|
|
if (i5 != 3) {
|
|
setDrawerLockMode(i5, GravityCompat.END);
|
|
}
|
|
}
|
|
|
|
@Override // android.view.View
|
|
public void onRtlPropertiesChanged(int i) {
|
|
resolveShadowDrawables();
|
|
}
|
|
|
|
/* JADX WARNING: Code restructure failed: missing block: B:12:0x0030, code lost:
|
|
r1.openDrawerGravity = r4.gravity;
|
|
*/
|
|
@Override // android.view.View
|
|
public Parcelable onSaveInstanceState() {
|
|
SavedState savedState = new SavedState(super.onSaveInstanceState());
|
|
int childCount = getChildCount();
|
|
int i = 0;
|
|
while (true) {
|
|
if (i >= childCount) {
|
|
break;
|
|
}
|
|
LayoutParams layoutParams = (LayoutParams) getChildAt(i).getLayoutParams();
|
|
int i2 = layoutParams.openState;
|
|
boolean z2 = true;
|
|
boolean z3 = i2 == 1;
|
|
if (i2 != 2) {
|
|
z2 = false;
|
|
}
|
|
if (z3 || z2) {
|
|
break;
|
|
}
|
|
i++;
|
|
}
|
|
savedState.lockModeLeft = this.mLockModeLeft;
|
|
savedState.lockModeRight = this.mLockModeRight;
|
|
savedState.lockModeStart = this.mLockModeStart;
|
|
savedState.lockModeEnd = this.mLockModeEnd;
|
|
return savedState;
|
|
}
|
|
|
|
@Override // android.view.View
|
|
public boolean onTouchEvent(MotionEvent motionEvent) {
|
|
boolean z2;
|
|
View findOpenDrawer;
|
|
this.mLeftDragger.processTouchEvent(motionEvent);
|
|
this.mRightDragger.processTouchEvent(motionEvent);
|
|
int action = motionEvent.getAction() & 255;
|
|
if (action == 0) {
|
|
float x2 = motionEvent.getX();
|
|
float y2 = motionEvent.getY();
|
|
this.mInitialMotionX = x2;
|
|
this.mInitialMotionY = y2;
|
|
this.mDisallowInterceptRequested = false;
|
|
this.mChildrenCanceledTouch = false;
|
|
} else if (action == 1) {
|
|
float x3 = motionEvent.getX();
|
|
float y3 = motionEvent.getY();
|
|
View findTopChildUnder = this.mLeftDragger.findTopChildUnder((int) x3, (int) y3);
|
|
if (findTopChildUnder != null && isContentView(findTopChildUnder)) {
|
|
float f = x3 - this.mInitialMotionX;
|
|
float f2 = y3 - this.mInitialMotionY;
|
|
int touchSlop = this.mLeftDragger.getTouchSlop();
|
|
if (!((f2 * f2) + (f * f) >= ((float) (touchSlop * touchSlop)) || (findOpenDrawer = findOpenDrawer()) == null || getDrawerLockMode(findOpenDrawer) == 2)) {
|
|
z2 = false;
|
|
closeDrawers(z2);
|
|
this.mDisallowInterceptRequested = false;
|
|
}
|
|
}
|
|
z2 = true;
|
|
closeDrawers(z2);
|
|
this.mDisallowInterceptRequested = false;
|
|
} else if (action == 3) {
|
|
closeDrawers(true);
|
|
this.mDisallowInterceptRequested = false;
|
|
this.mChildrenCanceledTouch = false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public void openDrawer(int i) {
|
|
openDrawer(i, true);
|
|
}
|
|
|
|
public void openDrawer(int i, boolean z2) {
|
|
View findDrawerWithGravity = findDrawerWithGravity(i);
|
|
if (findDrawerWithGravity != null) {
|
|
openDrawer(findDrawerWithGravity, z2);
|
|
return;
|
|
}
|
|
StringBuilder P = a.P("No drawer view found with gravity ");
|
|
P.append(gravityToString(i));
|
|
throw new IllegalArgumentException(P.toString());
|
|
}
|
|
|
|
public void openDrawer(@NonNull View view) {
|
|
openDrawer(view, true);
|
|
}
|
|
|
|
public void openDrawer(@NonNull View view, boolean z2) {
|
|
if (isDrawerView(view)) {
|
|
LayoutParams layoutParams = (LayoutParams) view.getLayoutParams();
|
|
if (this.mFirstLayout) {
|
|
layoutParams.onScreen = 1.0f;
|
|
layoutParams.openState = 1;
|
|
updateChildrenImportantForAccessibility(view, true);
|
|
} else if (z2) {
|
|
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(layoutParams.gravity, 0, view);
|
|
view.setVisibility(0);
|
|
}
|
|
invalidate();
|
|
return;
|
|
}
|
|
throw new IllegalArgumentException("View " + view + " is not a sliding drawer");
|
|
}
|
|
|
|
public void removeDrawerListener(@NonNull DrawerListener drawerListener) {
|
|
List<DrawerListener> list;
|
|
if (drawerListener != null && (list = this.mListeners) != null) {
|
|
list.remove(drawerListener);
|
|
}
|
|
}
|
|
|
|
@Override // android.view.ViewGroup, android.view.ViewParent
|
|
public void requestDisallowInterceptTouchEvent(boolean z2) {
|
|
super.requestDisallowInterceptTouchEvent(z2);
|
|
this.mDisallowInterceptRequested = z2;
|
|
if (z2) {
|
|
closeDrawers(true);
|
|
}
|
|
}
|
|
|
|
@Override // android.view.ViewParent, android.view.View
|
|
public void requestLayout() {
|
|
if (!this.mInLayout) {
|
|
super.requestLayout();
|
|
}
|
|
}
|
|
|
|
@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
|
|
public void setChildInsets(Object obj, boolean z2) {
|
|
this.mLastInsets = obj;
|
|
this.mDrawStatusBarBackground = z2;
|
|
setWillNotDraw(!z2 && getBackground() == null);
|
|
requestLayout();
|
|
}
|
|
|
|
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);
|
|
}
|
|
}
|
|
}
|
|
|
|
@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 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) {
|
|
View findDrawerWithGravity2 = findDrawerWithGravity(absoluteGravity);
|
|
if (findDrawerWithGravity2 != null) {
|
|
closeDrawer(findDrawerWithGravity2);
|
|
}
|
|
} else if (i == 2 && (findDrawerWithGravity = findDrawerWithGravity(absoluteGravity)) != null) {
|
|
openDrawer(findDrawerWithGravity);
|
|
}
|
|
}
|
|
|
|
public void setDrawerLockMode(int i, @NonNull View view) {
|
|
if (isDrawerView(view)) {
|
|
setDrawerLockMode(i, ((LayoutParams) view.getLayoutParams()).gravity);
|
|
return;
|
|
}
|
|
throw new IllegalArgumentException("View " + view + " is not a drawer with appropriate layout_gravity");
|
|
}
|
|
|
|
public void setDrawerShadow(@DrawableRes int i, int i2) {
|
|
setDrawerShadow(ContextCompat.getDrawable(getContext(), i), i2);
|
|
}
|
|
|
|
public void setDrawerShadow(Drawable drawable, int i) {
|
|
if (!SET_DRAWER_SHADOW_FROM_ELEVATION) {
|
|
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) {
|
|
this.mShadowRight = drawable;
|
|
} else {
|
|
return;
|
|
}
|
|
resolveShadowDrawables();
|
|
invalidate();
|
|
}
|
|
}
|
|
|
|
public void setDrawerTitle(int i, @Nullable CharSequence charSequence) {
|
|
int absoluteGravity = GravityCompat.getAbsoluteGravity(i, ViewCompat.getLayoutDirection(this));
|
|
if (absoluteGravity == 3) {
|
|
this.mTitleLeft = charSequence;
|
|
} else if (absoluteGravity == 5) {
|
|
this.mTitleRight = charSequence;
|
|
}
|
|
}
|
|
|
|
public void setDrawerViewOffset(View view, float f) {
|
|
LayoutParams layoutParams = (LayoutParams) view.getLayoutParams();
|
|
if (f != layoutParams.onScreen) {
|
|
layoutParams.onScreen = f;
|
|
dispatchOnDrawerSlide(view, f);
|
|
}
|
|
}
|
|
|
|
public void setScrimColor(@ColorInt int i) {
|
|
this.mScrimColor = i;
|
|
invalidate();
|
|
}
|
|
|
|
public void setStatusBarBackground(int i) {
|
|
this.mStatusBarBackground = i != 0 ? ContextCompat.getDrawable(getContext(), i) : null;
|
|
invalidate();
|
|
}
|
|
|
|
public void setStatusBarBackground(@Nullable Drawable drawable) {
|
|
this.mStatusBarBackground = drawable;
|
|
invalidate();
|
|
}
|
|
|
|
public void setStatusBarBackgroundColor(@ColorInt int i) {
|
|
this.mStatusBarBackground = new ColorDrawable(i);
|
|
invalidate();
|
|
}
|
|
|
|
public void updateDrawerState(int i, int i2, View view) {
|
|
int viewDragState = this.mLeftDragger.getViewDragState();
|
|
int viewDragState2 = this.mRightDragger.getViewDragState();
|
|
int i3 = 2;
|
|
if (viewDragState == 1 || viewDragState2 == 1) {
|
|
i3 = 1;
|
|
} else if (!(viewDragState == 2 || viewDragState2 == 2)) {
|
|
i3 = 0;
|
|
}
|
|
if (view != null && i2 == 0) {
|
|
float f = ((LayoutParams) view.getLayoutParams()).onScreen;
|
|
if (f == 0.0f) {
|
|
dispatchOnDrawerClosed(view);
|
|
} else if (f == 1.0f) {
|
|
dispatchOnDrawerOpened(view);
|
|
}
|
|
}
|
|
if (i3 != this.mDrawerState) {
|
|
this.mDrawerState = i3;
|
|
List<DrawerListener> list = this.mListeners;
|
|
if (list != null) {
|
|
for (int size = list.size() - 1; size >= 0; size--) {
|
|
this.mListeners.get(size).onDrawerStateChanged(i3);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|