CrackMe.apk
Download file
package androidx.drawerlayout.widget;
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.ViewParent;
import android.view.WindowInsets;
import android.view.accessibility.AccessibilityEvent;
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 java.util.ArrayList;
import java.util.List;
public class DrawerLayout extends ViewGroup {
private static final boolean ALLOW_EDGE_LOCK = false;
static final boolean CAN_HIDE_DESCENDANTS = (Build.VERSION.SDK_INT >= 19);
private static final boolean CHILDREN_DISALLOW_INTERCEPT = true;
private static final int DEFAULT_SCRIM_COLOR = -1728053248;
private static final int DRAWER_ELEVATION = 10;
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;
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;
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;
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 {
public void onDrawerClosed(View view) {
}
public void onDrawerOpened(View view) {
}
public void onDrawerSlide(View view, float f) {
}
public void onDrawerStateChanged(int i) {
}
}
static {
boolean z = true;
if (Build.VERSION.SDK_INT < 21) {
z = false;
}
SET_DRAWER_SHADOW_FROM_ELEVATION = z;
}
public DrawerLayout(Context context) {
this(context, (AttributeSet) null);
}
public DrawerLayout(Context context, AttributeSet attributeSet) {
this(context, attributeSet, 0);
}
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 = 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)) {
if (Build.VERSION.SDK_INT >= 21) {
setOnApplyWindowInsetsListener(new View.OnApplyWindowInsetsListener() {
public WindowInsets onApplyWindowInsets(View view, WindowInsets windowInsets) {
((DrawerLayout) view).setChildInsets(windowInsets, windowInsets.getSystemWindowInsetTop() > 0);
return windowInsets.consumeSystemWindowInsets();
}
});
setSystemUiVisibility(1280);
TypedArray obtainStyledAttributes = context.obtainStyledAttributes(THEME_ATTRS);
try {
this.mStatusBarBackground = obtainStyledAttributes.getDrawable(0);
} finally {
obtainStyledAttributes.recycle();
}
} else {
this.mStatusBarBackground = null;
}
}
this.mDrawerElevation = f * 10.0f;
this.mNonDrawerViews = new ArrayList<>();
}
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 float getDrawerElevation() {
if (SET_DRAWER_SHADOW_FROM_ELEVATION) {
return this.mDrawerElevation;
}
return 0.0f;
}
public void setChildInsets(Object obj, boolean z) {
this.mLastInsets = obj;
this.mDrawStatusBarBackground = z;
setWillNotDraw(!z && getBackground() == null);
requestLayout();
}
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 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) {
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) {
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) {
View findDrawerWithGravity2 = findDrawerWithGravity(absoluteGravity);
if (findDrawerWithGravity2 != null) {
closeDrawer(findDrawerWithGravity2);
}
} else if (i == 2 && (findDrawerWithGravity = findDrawerWithGravity(absoluteGravity)) != null) {
openDrawer(findDrawerWithGravity);
}
}
public void setDrawerLockMode(int i, 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 int getDrawerLockMode(int i) {
int i2;
int i3;
int i4;
int layoutDirection = ViewCompat.getLayoutDirection(this);
if (i == 3) {
int i5 = this.mLockModeLeft;
if (i5 != 3) {
return i5;
}
int i6 = layoutDirection == 0 ? this.mLockModeStart : this.mLockModeEnd;
if (i6 != 3) {
return i6;
}
return 0;
} else if (i == 5) {
int i7 = this.mLockModeRight;
if (i7 != 3) {
return i7;
}
if (layoutDirection == 0) {
i2 = this.mLockModeEnd;
} else {
i2 = this.mLockModeStart;
}
if (i2 != 3) {
return i2;
}
return 0;
} else if (i == 8388611) {
int i8 = this.mLockModeStart;
if (i8 != 3) {
return i8;
}
if (layoutDirection == 0) {
i3 = this.mLockModeLeft;
} else {
i3 = this.mLockModeRight;
}
if (i3 != 3) {
return i3;
}
return 0;
} else if (i != 8388613) {
return 0;
} else {
int i9 = this.mLockModeEnd;
if (i9 != 3) {
return i9;
}
if (layoutDirection == 0) {
i4 = this.mLockModeRight;
} else {
i4 = this.mLockModeLeft;
}
if (i4 != 3) {
return i4;
}
return 0;
}
}
public int getDrawerLockMode(View view) {
if (isDrawerView(view)) {
return getDrawerLockMode(((LayoutParams) view.getLayoutParams()).gravity);
}
throw new IllegalArgumentException("View " + view + " is not a drawer");
}
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 = (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;
}
/* access modifiers changed from: package-private */
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) {
LayoutParams layoutParams = (LayoutParams) view.getLayoutParams();
if (layoutParams.onScreen == 0.0f) {
dispatchOnDrawerClosed(view);
} else if (layoutParams.onScreen == 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);
}
}
}
}
/* access modifiers changed from: package-private */
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);
}
}
}
/* access modifiers changed from: package-private */
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);
}
}
}
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, 4);
} else {
ViewCompat.setImportantForAccessibility(childAt, 1);
}
}
}
/* access modifiers changed from: package-private */
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);
}
}
}
/* access modifiers changed from: package-private */
public void setDrawerViewOffset(View view, float f) {
LayoutParams layoutParams = (LayoutParams) view.getLayoutParams();
if (f != layoutParams.onScreen) {
layoutParams.onScreen = f;
dispatchOnDrawerSlide(view, f);
}
}
/* access modifiers changed from: package-private */
public float getDrawerViewOffset(View view) {
return ((LayoutParams) view.getLayoutParams()).onScreen;
}
/* access modifiers changed from: package-private */
public int getDrawerViewAbsoluteGravity(View view) {
return GravityCompat.getAbsoluteGravity(((LayoutParams) view.getLayoutParams()).gravity, ViewCompat.getLayoutDirection(this));
}
/* access modifiers changed from: package-private */
public boolean checkDrawerViewAbsoluteGravity(View view, int i) {
return (getDrawerViewAbsoluteGravity(view) & i) == i;
}
/* access modifiers changed from: package-private */
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;
}
/* access modifiers changed from: package-private */
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);
}
/* access modifiers changed from: package-private */
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;
}
static String gravityToString(int i) {
if ((i & 3) == 3) {
return "LEFT";
}
return (i & 5) == 5 ? "RIGHT" : Integer.toHexString(i);
}
/* access modifiers changed from: protected */
public void onDetachedFromWindow() {
super.onDetachedFromWindow();
this.mFirstLayout = true;
}
/* access modifiers changed from: protected */
public void onAttachedToWindow() {
super.onAttachedToWindow();
this.mFirstLayout = true;
}
/* access modifiers changed from: protected */
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 z = this.mLastInsets != null && ViewCompat.getFitsSystemWindows(this);
int layoutDirection = ViewCompat.getLayoutDirection(this);
int childCount = getChildCount();
int i4 = 0;
boolean z2 = false;
boolean z3 = false;
while (i4 < childCount) {
View childAt = getChildAt(i4);
if (childAt.getVisibility() != 8) {
LayoutParams layoutParams = (LayoutParams) childAt.getLayoutParams();
if (z) {
int absoluteGravity = GravityCompat.getAbsoluteGravity(layoutParams.gravity, layoutDirection);
if (ViewCompat.getFitsSystemWindows(childAt)) {
if (Build.VERSION.SDK_INT >= 21) {
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 if (Build.VERSION.SDK_INT >= 21) {
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());
}
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, 1073741824), View.MeasureSpec.makeMeasureSpec((size2 - layoutParams.topMargin) - layoutParams.bottomMargin, 1073741824));
} 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;
if ((!z4 || !z2) && (z4 || !z3)) {
if (z4) {
z2 = true;
} else {
z3 = true;
}
childAt.measure(getChildMeasureSpec(i, this.mMinDrawerMargin + layoutParams.leftMargin + layoutParams.rightMargin, layoutParams.width), getChildMeasureSpec(i2, layoutParams.topMargin + layoutParams.bottomMargin, layoutParams.height));
i4++;
i3 = 0;
} else {
throw new IllegalStateException("Child drawer has absolute gravity " + gravityToString(drawerViewAbsoluteGravity) + " but this " + TAG + " already has a " + "drawer view along that edge");
}
} 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");
}
}
int i5 = i;
int i6 = i2;
i4++;
i3 = 0;
}
}
private void resolveShadowDrawables() {
if (!SET_DRAWER_SHADOW_FROM_ELEVATION) {
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 boolean mirror(Drawable drawable, int i) {
if (drawable == null || !DrawableCompat.isAutoMirrored(drawable)) {
return false;
}
DrawableCompat.setLayoutDirection(drawable, i);
return true;
}
/* access modifiers changed from: protected */
public void onLayout(boolean z, 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)) {
childAt.layout(layoutParams.leftMargin, layoutParams.topMargin, layoutParams.leftMargin + childAt.getMeasuredWidth(), layoutParams.topMargin + childAt.getMeasuredHeight());
} 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 i8 = i6 - ((int) (layoutParams.onScreen * f3));
f = ((float) (i6 - i8)) / f3;
i5 = i8;
}
boolean z2 = f != layoutParams.onScreen;
int i9 = layoutParams.gravity & 112;
if (i9 == 16) {
int i10 = i4 - i2;
int i11 = (i10 - measuredHeight) / 2;
if (i11 < layoutParams.topMargin) {
i11 = layoutParams.topMargin;
} else if (i11 + measuredHeight > i10 - layoutParams.bottomMargin) {
i11 = (i10 - layoutParams.bottomMargin) - measuredHeight;
}
childAt.layout(i5, i11, measuredWidth + i5, measuredHeight + i11);
} else if (i9 != 80) {
childAt.layout(i5, layoutParams.topMargin, measuredWidth + i5, layoutParams.topMargin + measuredHeight);
} else {
int i12 = i4 - i2;
childAt.layout(i5, (i12 - layoutParams.bottomMargin) - childAt.getMeasuredHeight(), measuredWidth + i5, i12 - layoutParams.bottomMargin);
}
if (z2) {
setDrawerViewOffset(childAt, f);
}
int i13 = layoutParams.onScreen > 0.0f ? 0 : 4;
if (childAt.getVisibility() != i13) {
childAt.setVisibility(i13);
}
}
}
}
this.mInLayout = false;
this.mFirstLayout = false;
}
public void requestLayout() {
if (!this.mInLayout) {
super.requestLayout();
}
}
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);
}
}
private static boolean hasOpaqueBackground(View view) {
Drawable background = view.getBackground();
if (background == null || background.getOpacity() != -1) {
return false;
}
return true;
}
public void setStatusBarBackground(Drawable drawable) {
this.mStatusBarBackground = drawable;
invalidate();
}
public Drawable getStatusBarBackgroundDrawable() {
return this.mStatusBarBackground;
}
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();
}
public void onRtlPropertiesChanged(int i) {
resolveShadowDrawables();
}
/* JADX WARNING: Code restructure failed: missing block: B:6:0x0012, code lost:
r0 = r4.mLastInsets;
*/
/* Code decompiled incorrectly, please refer to instructions dump. */
public void onDraw(android.graphics.Canvas r5) {
/*
r4 = this;
super.onDraw(r5)
boolean r0 = r4.mDrawStatusBarBackground
if (r0 == 0) goto L_0x002e
android.graphics.drawable.Drawable r0 = r4.mStatusBarBackground
if (r0 == 0) goto L_0x002e
int r0 = android.os.Build.VERSION.SDK_INT
r1 = 21
r2 = 0
if (r0 < r1) goto L_0x001d
java.lang.Object r0 = r4.mLastInsets
if (r0 == 0) goto L_0x001d
android.view.WindowInsets r0 = (android.view.WindowInsets) r0
int r0 = r0.getSystemWindowInsetTop()
goto L_0x001e
L_0x001d:
r0 = 0
L_0x001e:
if (r0 <= 0) goto L_0x002e
android.graphics.drawable.Drawable r1 = r4.mStatusBarBackground
int r3 = r4.getWidth()
r1.setBounds(r2, r2, r3, r0)
android.graphics.drawable.Drawable r0 = r4.mStatusBarBackground
r0.draw(r5)
L_0x002e:
return
*/
throw new UnsupportedOperationException("Method not decompiled: androidx.drawerlayout.widget.DrawerLayout.onDraw(android.graphics.Canvas):void");
}
/* access modifiers changed from: protected */
public boolean drawChild(Canvas canvas, View view, long j) {
Canvas canvas2 = canvas;
View view2 = view;
int height = getHeight();
boolean isContentView = isContentView(view2);
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 != view2 && 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(view2, 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(view2, 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;
}
/* access modifiers changed from: package-private */
public boolean isContentView(View view) {
return ((LayoutParams) view.getLayoutParams()).gravity == 0;
}
/* access modifiers changed from: package-private */
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;
}
/* JADX WARNING: Code restructure failed: missing block: B:13:0x004d, code lost:
r7 = r6.mLeftDragger.findTopChildUnder((int) r0, (int) r7);
*/
/* JADX WARNING: Code restructure failed: missing block: B:5:0x001b, code lost:
if (r0 != 3) goto L_0x0038;
*/
/* Code decompiled incorrectly, please refer to instructions dump. */
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 L_0x003a
if (r0 == r2) goto L_0x0031
r7 = 2
r4 = 3
if (r0 == r7) goto L_0x001e
if (r0 == r4) goto L_0x0031
goto L_0x0038
L_0x001e:
androidx.customview.widget.ViewDragHelper r7 = r6.mLeftDragger
boolean r7 = r7.checkTouchSlop(r4)
if (r7 == 0) goto L_0x0038
androidx.drawerlayout.widget.DrawerLayout$ViewDragCallback r7 = r6.mLeftCallback
r7.removeCallbacks()
androidx.drawerlayout.widget.DrawerLayout$ViewDragCallback r7 = r6.mRightCallback
r7.removeCallbacks()
goto L_0x0038
L_0x0031:
r6.closeDrawers(r2)
r6.mDisallowInterceptRequested = r3
r6.mChildrenCanceledTouch = r3
L_0x0038:
r7 = 0
goto L_0x0064
L_0x003a:
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 L_0x005f
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 L_0x005f
boolean r7 = r6.isContentView(r7)
if (r7 == 0) goto L_0x005f
r7 = 1
goto L_0x0060
L_0x005f:
r7 = 0
L_0x0060:
r6.mDisallowInterceptRequested = r3
r6.mChildrenCanceledTouch = r3
L_0x0064:
if (r1 != 0) goto L_0x0074
if (r7 != 0) goto L_0x0074
boolean r7 = r6.hasPeekingDrawer()
if (r7 != 0) goto L_0x0074
boolean r7 = r6.mChildrenCanceledTouch
if (r7 == 0) goto L_0x0073
goto L_0x0074
L_0x0073:
r2 = 0
L_0x0074:
return r2
*/
throw new UnsupportedOperationException("Method not decompiled: androidx.drawerlayout.widget.DrawerLayout.onInterceptTouchEvent(android.view.MotionEvent):boolean");
}
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 true;
}
}
return false;
}
public boolean onTouchEvent(MotionEvent motionEvent) {
boolean z;
View findOpenDrawer;
this.mLeftDragger.processTouchEvent(motionEvent);
this.mRightDragger.processTouchEvent(motionEvent);
int action = motionEvent.getAction() & 255;
if (action == 0) {
float x = motionEvent.getX();
float y = motionEvent.getY();
this.mInitialMotionX = x;
this.mInitialMotionY = y;
this.mDisallowInterceptRequested = false;
this.mChildrenCanceledTouch = false;
} else if (action == 1) {
float x2 = motionEvent.getX();
float y2 = motionEvent.getY();
View findTopChildUnder = this.mLeftDragger.findTopChildUnder((int) x2, (int) y2);
if (findTopChildUnder != null && isContentView(findTopChildUnder)) {
float f = x2 - this.mInitialMotionX;
float f2 = y2 - this.mInitialMotionY;
int touchSlop = this.mLeftDragger.getTouchSlop();
if (!((f * f) + (f2 * f2) >= ((float) (touchSlop * touchSlop)) || (findOpenDrawer = findOpenDrawer()) == null || getDrawerLockMode(findOpenDrawer) == 2)) {
z = false;
closeDrawers(z);
this.mDisallowInterceptRequested = false;
}
}
z = true;
closeDrawers(z);
this.mDisallowInterceptRequested = false;
} else if (action == 3) {
closeDrawers(true);
this.mDisallowInterceptRequested = false;
this.mChildrenCanceledTouch = false;
}
return true;
}
public void requestDisallowInterceptTouchEvent(boolean z) {
super.requestDisallowInterceptTouchEvent(z);
this.mDisallowInterceptRequested = z;
if (z) {
closeDrawers(true);
}
}
public void closeDrawers() {
closeDrawers(false);
}
/* access modifiers changed from: package-private */
public void closeDrawers(boolean z) {
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) && (!z || layoutParams.isPeeking)) {
int width = childAt.getWidth();
if (checkDrawerViewAbsoluteGravity(childAt, 3)) {
z2 = this.mLeftDragger.smoothSlideViewTo(childAt, -width, childAt.getTop());
} else {
z2 = this.mRightDragger.smoothSlideViewTo(childAt, getWidth(), childAt.getTop());
}
z3 |= z2;
layoutParams.isPeeking = false;
}
}
this.mLeftCallback.removeCallbacks();
this.mRightCallback.removeCallbacks();
if (z3) {
invalidate();
}
}
public void openDrawer(View view) {
openDrawer(view, true);
}
public void openDrawer(View view, boolean z) {
if (isDrawerView(view)) {
LayoutParams layoutParams = (LayoutParams) view.getLayoutParams();
if (this.mFirstLayout) {
layoutParams.onScreen = 1.0f;
layoutParams.openState = 1;
updateChildrenImportantForAccessibility(view, true);
} 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(layoutParams.gravity, 0, view);
view.setVisibility(0);
}
invalidate();
return;
}
throw new IllegalArgumentException("View " + view + " is not a sliding drawer");
}
public void openDrawer(int i) {
openDrawer(i, true);
}
public void openDrawer(int i, boolean z) {
View findDrawerWithGravity = findDrawerWithGravity(i);
if (findDrawerWithGravity != null) {
openDrawer(findDrawerWithGravity, z);
return;
}
throw new IllegalArgumentException("No drawer view found with gravity " + gravityToString(i));
}
public void closeDrawer(View view) {
closeDrawer(view, true);
}
public void closeDrawer(View view, boolean z) {
if (isDrawerView(view)) {
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(layoutParams.gravity, 0, view);
view.setVisibility(4);
}
invalidate();
return;
}
throw new IllegalArgumentException("View " + view + " is not a sliding drawer");
}
public void closeDrawer(int i) {
closeDrawer(i, true);
}
public void closeDrawer(int i, boolean z) {
View findDrawerWithGravity = findDrawerWithGravity(i);
if (findDrawerWithGravity != null) {
closeDrawer(findDrawerWithGravity, z);
return;
}
throw new IllegalArgumentException("No drawer view found with gravity " + gravityToString(i));
}
public boolean isDrawerOpen(View view) {
if (isDrawerView(view)) {
return (((LayoutParams) view.getLayoutParams()).openState & 1) == 1;
}
throw new IllegalArgumentException("View " + view + " is not a drawer");
}
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)) {
return ((LayoutParams) view.getLayoutParams()).onScreen > 0.0f;
}
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 true;
}
}
return false;
}
/* access modifiers changed from: protected */
public ViewGroup.LayoutParams generateDefaultLayoutParams() {
return new LayoutParams(-1, -1);
}
/* access modifiers changed from: protected */
public ViewGroup.LayoutParams generateLayoutParams(ViewGroup.LayoutParams layoutParams) {
if (layoutParams instanceof LayoutParams) {
return new LayoutParams((LayoutParams) layoutParams);
}
return layoutParams instanceof ViewGroup.MarginLayoutParams ? new LayoutParams((ViewGroup.MarginLayoutParams) layoutParams) : new LayoutParams(layoutParams);
}
/* access modifiers changed from: protected */
public boolean checkLayoutParams(ViewGroup.LayoutParams layoutParams) {
return (layoutParams instanceof LayoutParams) && super.checkLayoutParams(layoutParams);
}
public ViewGroup.LayoutParams generateLayoutParams(AttributeSet attributeSet) {
return new LayoutParams(getContext(), attributeSet);
}
public void addFocusables(ArrayList<View> arrayList, int i, int i2) {
if (getDescendantFocusability() != 393216) {
int childCount = getChildCount();
boolean z = 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);
z = true;
}
}
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() {
return findVisibleDrawer() != null;
}
/* access modifiers changed from: package-private */
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;
}
/* access modifiers changed from: package-private */
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 onKeyDown(int i, KeyEvent keyEvent) {
if (i != 4 || !hasVisibleDrawer()) {
return super.onKeyDown(i, keyEvent);
}
keyEvent.startTracking();
return true;
}
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;
}
/* access modifiers changed from: protected */
public 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, (int) GravityCompat.START);
}
if (savedState.lockModeEnd != 3) {
setDrawerLockMode(savedState.lockModeEnd, (int) GravityCompat.END);
}
}
/* access modifiers changed from: protected */
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();
boolean z = true;
boolean z2 = layoutParams.openState == 1;
if (layoutParams.openState != 2) {
z = false;
}
if (z2 || z) {
savedState.openDrawerGravity = layoutParams.gravity;
} else {
i++;
}
}
savedState.lockModeLeft = this.mLockModeLeft;
savedState.lockModeRight = this.mLockModeRight;
savedState.lockModeStart = this.mLockModeStart;
savedState.lockModeEnd = this.mLockModeEnd;
return savedState;
}
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);
}
}
static boolean includeChildForAccessibility(View view) {
return (ViewCompat.getImportantForAccessibility(view) == 4 || ViewCompat.getImportantForAccessibility(view) == 2) ? false : true;
}
protected static class SavedState extends AbsSavedState {
public static final Parcelable.Creator<SavedState> CREATOR = new Parcelable.ClassLoaderCreator<SavedState>() {
public SavedState createFromParcel(Parcel parcel, ClassLoader classLoader) {
return new SavedState(parcel, classLoader);
}
public SavedState createFromParcel(Parcel parcel) {
return new SavedState(parcel, (ClassLoader) null);
}
public SavedState[] newArray(int i) {
return new SavedState[i];
}
};
int lockModeEnd;
int lockModeLeft;
int lockModeRight;
int lockModeStart;
int openDrawerGravity = 0;
public SavedState(Parcel parcel, 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(Parcelable parcelable) {
super(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() {
public void run() {
ViewDragCallback.this.peekDrawer();
}
};
public boolean onEdgeLock(int i) {
return false;
}
ViewDragCallback(int i) {
this.mAbsGravity = i;
}
public void setDragger(ViewDragHelper viewDragHelper) {
this.mDragger = viewDragHelper;
}
public void removeCallbacks() {
DrawerLayout.this.removeCallbacks(this.mPeekRunnable);
}
public boolean tryCaptureView(View view, int i) {
return DrawerLayout.this.isDrawerView(view) && DrawerLayout.this.checkDrawerViewAbsoluteGravity(view, this.mAbsGravity) && DrawerLayout.this.getDrawerLockMode(view) == 0;
}
public void onViewDragStateChanged(int i) {
DrawerLayout.this.updateDrawerState(this.mAbsGravity, i, this.mDragger.getCapturedView());
}
public void onViewPositionChanged(View view, int i, int i2, int i3, int i4) {
float f;
int width = view.getWidth();
if (DrawerLayout.this.checkDrawerViewAbsoluteGravity(view, 3)) {
f = (float) (i + width);
} else {
f = (float) (DrawerLayout.this.getWidth() - i);
}
float f2 = f / ((float) width);
DrawerLayout.this.setDrawerViewOffset(view, f2);
view.setVisibility(f2 == 0.0f ? 4 : 0);
DrawerLayout.this.invalidate();
}
public void onViewCaptured(View view, int i) {
((LayoutParams) view.getLayoutParams()).isPeeking = false;
closeOtherDrawer();
}
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);
}
}
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 onEdgeTouched(int i, int i2) {
DrawerLayout.this.postDelayed(this.mPeekRunnable, 160);
}
/* access modifiers changed from: package-private */
public void peekDrawer() {
View view;
int i;
int edgeSize = this.mDragger.getEdgeSize();
int i2 = 0;
boolean z = this.mAbsGravity == 3;
if (z) {
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 (((z && view.getLeft() < i) || (!z && 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 onEdgeDragStarted(int i, int i2) {
View view;
if ((i & 1) == 1) {
view = DrawerLayout.this.findDrawerWithGravity(3);
} else {
view = DrawerLayout.this.findDrawerWithGravity(5);
}
if (view != null && DrawerLayout.this.getDrawerLockMode(view) == 0) {
this.mDragger.captureChildView(view, i2);
}
}
public int getViewHorizontalDragRange(View view) {
if (DrawerLayout.this.isDrawerView(view)) {
return view.getWidth();
}
return 0;
}
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));
}
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(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() {
}
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);
}
public void onInitializeAccessibilityEvent(View view, AccessibilityEvent accessibilityEvent) {
super.onInitializeAccessibilityEvent(view, accessibilityEvent);
accessibilityEvent.setClassName(DrawerLayout.class.getName());
}
public boolean dispatchPopulateAccessibilityEvent(View view, AccessibilityEvent accessibilityEvent) {
CharSequence drawerTitle;
if (accessibilityEvent.getEventType() != 32) {
return super.dispatchPopulateAccessibilityEvent(view, accessibilityEvent);
}
List 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;
}
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.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());
}
}
static final class ChildAccessibilityDelegate extends AccessibilityDelegateCompat {
ChildAccessibilityDelegate() {
}
public void onInitializeAccessibilityNodeInfo(View view, AccessibilityNodeInfoCompat accessibilityNodeInfoCompat) {
super.onInitializeAccessibilityNodeInfo(view, accessibilityNodeInfoCompat);
if (!DrawerLayout.includeChildForAccessibility(view)) {
accessibilityNodeInfoCompat.setParent((View) null);
}
}
}
}
Download file