CrackMe.apk
Download file
package com.google.android.material.floatingactionbutton;
import android.animation.Animator;
import android.animation.AnimatorListenerAdapter;
import android.animation.AnimatorSet;
import android.animation.PropertyValuesHolder;
import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Rect;
import android.text.TextUtils;
import android.util.AttributeSet;
import android.util.Property;
import android.view.View;
import android.view.ViewGroup;
import androidx.coordinatorlayout.widget.CoordinatorLayout;
import androidx.core.view.ViewCompat;
import com.google.android.material.R;
import com.google.android.material.animation.MotionSpec;
import com.google.android.material.appbar.AppBarLayout;
import com.google.android.material.bottomsheet.BottomSheetBehavior;
import com.google.android.material.button.MaterialButton;
import com.google.android.material.internal.DescendantOffsetUtils;
import com.google.android.material.internal.ThemeEnforcement;
import com.google.android.material.shape.ShapeAppearanceModel;
import java.util.List;
public class ExtendedFloatingActionButton extends MaterialButton implements CoordinatorLayout.AttachedBehavior {
private static final int ANIM_STATE_HIDING = 1;
private static final int ANIM_STATE_NONE = 0;
private static final int ANIM_STATE_SHOWING = 2;
private static final int DEF_STYLE_RES = R.style.Widget_MaterialComponents_ExtendedFloatingActionButton_Icon;
static final Property<View, Float> HEIGHT = new Property<View, Float>(Float.class, "height") {
public void set(View view, Float f) {
view.getLayoutParams().height = f.intValue();
view.requestLayout();
}
public Float get(View view) {
return Float.valueOf((float) view.getLayoutParams().height);
}
};
static final Property<View, Float> WIDTH = new Property<View, Float>(Float.class, "width") {
public void set(View view, Float f) {
view.getLayoutParams().width = f.intValue();
view.requestLayout();
}
public Float get(View view) {
return Float.valueOf((float) view.getLayoutParams().width);
}
};
/* access modifiers changed from: private */
public int animState;
private final CoordinatorLayout.Behavior<ExtendedFloatingActionButton> behavior;
private final AnimatorTracker changeVisibilityTracker;
/* access modifiers changed from: private */
public final MotionStrategy extendStrategy;
/* access modifiers changed from: private */
public final MotionStrategy hideStrategy;
/* access modifiers changed from: private */
public boolean isExtended;
/* access modifiers changed from: private */
public final Rect shadowPadding;
/* access modifiers changed from: private */
public final MotionStrategy showStrategy;
/* access modifiers changed from: private */
public final MotionStrategy shrinkStrategy;
public static abstract class OnChangedCallback {
public void onExtended(ExtendedFloatingActionButton extendedFloatingActionButton) {
}
public void onHidden(ExtendedFloatingActionButton extendedFloatingActionButton) {
}
public void onShown(ExtendedFloatingActionButton extendedFloatingActionButton) {
}
public void onShrunken(ExtendedFloatingActionButton extendedFloatingActionButton) {
}
}
interface Size {
int getHeight();
int getWidth();
}
public ExtendedFloatingActionButton(Context context) {
this(context, (AttributeSet) null);
}
public ExtendedFloatingActionButton(Context context, AttributeSet attributeSet) {
this(context, attributeSet, R.attr.extendedFloatingActionButtonStyle);
}
/* JADX INFO: super call moved to the top of the method (can break code semantics) */
public ExtendedFloatingActionButton(Context context, AttributeSet attributeSet, int i) {
super(context, attributeSet, i);
Context context2 = context;
AttributeSet attributeSet2 = attributeSet;
this.shadowPadding = new Rect();
this.animState = 0;
AnimatorTracker animatorTracker = new AnimatorTracker();
this.changeVisibilityTracker = animatorTracker;
ShowStrategy showStrategy2 = new ShowStrategy(animatorTracker);
this.showStrategy = showStrategy2;
HideStrategy hideStrategy2 = new HideStrategy(animatorTracker);
this.hideStrategy = hideStrategy2;
this.isExtended = true;
this.behavior = new ExtendedFloatingActionButtonBehavior(context2, attributeSet2);
int[] iArr = R.styleable.ExtendedFloatingActionButton;
int i2 = DEF_STYLE_RES;
TypedArray obtainStyledAttributes = ThemeEnforcement.obtainStyledAttributes(context, attributeSet, iArr, i, i2, new int[0]);
MotionSpec createFromAttribute = MotionSpec.createFromAttribute(context2, obtainStyledAttributes, R.styleable.ExtendedFloatingActionButton_showMotionSpec);
MotionSpec createFromAttribute2 = MotionSpec.createFromAttribute(context2, obtainStyledAttributes, R.styleable.ExtendedFloatingActionButton_hideMotionSpec);
MotionSpec createFromAttribute3 = MotionSpec.createFromAttribute(context2, obtainStyledAttributes, R.styleable.ExtendedFloatingActionButton_extendMotionSpec);
MotionSpec createFromAttribute4 = MotionSpec.createFromAttribute(context2, obtainStyledAttributes, R.styleable.ExtendedFloatingActionButton_shrinkMotionSpec);
AnimatorTracker animatorTracker2 = new AnimatorTracker();
ChangeSizeStrategy changeSizeStrategy = new ChangeSizeStrategy(animatorTracker2, new Size() {
public int getWidth() {
return ExtendedFloatingActionButton.this.getMeasuredWidth();
}
public int getHeight() {
return ExtendedFloatingActionButton.this.getMeasuredHeight();
}
}, true);
this.extendStrategy = changeSizeStrategy;
ChangeSizeStrategy changeSizeStrategy2 = new ChangeSizeStrategy(animatorTracker2, new Size() {
public int getWidth() {
return ExtendedFloatingActionButton.this.getCollapsedSize();
}
public int getHeight() {
return ExtendedFloatingActionButton.this.getCollapsedSize();
}
}, false);
this.shrinkStrategy = changeSizeStrategy2;
showStrategy2.setMotionSpec(createFromAttribute);
hideStrategy2.setMotionSpec(createFromAttribute2);
changeSizeStrategy.setMotionSpec(createFromAttribute3);
changeSizeStrategy2.setMotionSpec(createFromAttribute4);
obtainStyledAttributes.recycle();
setShapeAppearanceModel(ShapeAppearanceModel.builder(context2, attributeSet2, i, i2, ShapeAppearanceModel.PILL).build());
}
/* access modifiers changed from: protected */
public void onAttachedToWindow() {
super.onAttachedToWindow();
if (this.isExtended && TextUtils.isEmpty(getText()) && getIcon() != null) {
this.isExtended = false;
this.shrinkStrategy.performNow();
}
}
public CoordinatorLayout.Behavior<ExtendedFloatingActionButton> getBehavior() {
return this.behavior;
}
public void setExtended(boolean z) {
if (this.isExtended != z) {
MotionStrategy motionStrategy = z ? this.extendStrategy : this.shrinkStrategy;
if (!motionStrategy.shouldCancel()) {
motionStrategy.performNow();
}
}
}
public final boolean isExtended() {
return this.isExtended;
}
public void addOnShowAnimationListener(Animator.AnimatorListener animatorListener) {
this.showStrategy.addAnimationListener(animatorListener);
}
public void removeOnShowAnimationListener(Animator.AnimatorListener animatorListener) {
this.showStrategy.removeAnimationListener(animatorListener);
}
public void addOnHideAnimationListener(Animator.AnimatorListener animatorListener) {
this.hideStrategy.addAnimationListener(animatorListener);
}
public void removeOnHideAnimationListener(Animator.AnimatorListener animatorListener) {
this.hideStrategy.removeAnimationListener(animatorListener);
}
public void addOnShrinkAnimationListener(Animator.AnimatorListener animatorListener) {
this.shrinkStrategy.addAnimationListener(animatorListener);
}
public void removeOnShrinkAnimationListener(Animator.AnimatorListener animatorListener) {
this.shrinkStrategy.removeAnimationListener(animatorListener);
}
public void addOnExtendAnimationListener(Animator.AnimatorListener animatorListener) {
this.extendStrategy.addAnimationListener(animatorListener);
}
public void removeOnExtendAnimationListener(Animator.AnimatorListener animatorListener) {
this.extendStrategy.removeAnimationListener(animatorListener);
}
public void hide() {
performMotion(this.hideStrategy, (OnChangedCallback) null);
}
public void hide(OnChangedCallback onChangedCallback) {
performMotion(this.hideStrategy, onChangedCallback);
}
public void show() {
performMotion(this.showStrategy, (OnChangedCallback) null);
}
public void show(OnChangedCallback onChangedCallback) {
performMotion(this.showStrategy, onChangedCallback);
}
public void extend() {
performMotion(this.extendStrategy, (OnChangedCallback) null);
}
public void extend(OnChangedCallback onChangedCallback) {
performMotion(this.extendStrategy, onChangedCallback);
}
public void shrink() {
performMotion(this.shrinkStrategy, (OnChangedCallback) null);
}
public void shrink(OnChangedCallback onChangedCallback) {
performMotion(this.shrinkStrategy, onChangedCallback);
}
public MotionSpec getShowMotionSpec() {
return this.showStrategy.getMotionSpec();
}
public void setShowMotionSpec(MotionSpec motionSpec) {
this.showStrategy.setMotionSpec(motionSpec);
}
public void setShowMotionSpecResource(int i) {
setShowMotionSpec(MotionSpec.createFromResource(getContext(), i));
}
public MotionSpec getHideMotionSpec() {
return this.hideStrategy.getMotionSpec();
}
public void setHideMotionSpec(MotionSpec motionSpec) {
this.hideStrategy.setMotionSpec(motionSpec);
}
public void setHideMotionSpecResource(int i) {
setHideMotionSpec(MotionSpec.createFromResource(getContext(), i));
}
public MotionSpec getExtendMotionSpec() {
return this.extendStrategy.getMotionSpec();
}
public void setExtendMotionSpec(MotionSpec motionSpec) {
this.extendStrategy.setMotionSpec(motionSpec);
}
public void setExtendMotionSpecResource(int i) {
setExtendMotionSpec(MotionSpec.createFromResource(getContext(), i));
}
public MotionSpec getShrinkMotionSpec() {
return this.shrinkStrategy.getMotionSpec();
}
public void setShrinkMotionSpec(MotionSpec motionSpec) {
this.shrinkStrategy.setMotionSpec(motionSpec);
}
public void setShrinkMotionSpecResource(int i) {
setShrinkMotionSpec(MotionSpec.createFromResource(getContext(), i));
}
/* access modifiers changed from: private */
public void performMotion(final MotionStrategy motionStrategy, final OnChangedCallback onChangedCallback) {
if (!motionStrategy.shouldCancel()) {
if (!shouldAnimateVisibilityChange()) {
motionStrategy.performNow();
motionStrategy.onChange(onChangedCallback);
return;
}
measure(0, 0);
AnimatorSet createAnimator = motionStrategy.createAnimator();
createAnimator.addListener(new AnimatorListenerAdapter() {
private boolean cancelled;
public void onAnimationStart(Animator animator) {
motionStrategy.onAnimationStart(animator);
this.cancelled = false;
}
public void onAnimationCancel(Animator animator) {
this.cancelled = true;
motionStrategy.onAnimationCancel();
}
public void onAnimationEnd(Animator animator) {
motionStrategy.onAnimationEnd();
if (!this.cancelled) {
motionStrategy.onChange(onChangedCallback);
}
}
});
for (Animator.AnimatorListener addListener : motionStrategy.getListeners()) {
createAnimator.addListener(addListener);
}
createAnimator.start();
}
}
/* access modifiers changed from: private */
public boolean isOrWillBeShown() {
if (getVisibility() != 0) {
if (this.animState == 2) {
return true;
}
return false;
} else if (this.animState != 1) {
return true;
} else {
return false;
}
}
/* access modifiers changed from: private */
public boolean isOrWillBeHidden() {
if (getVisibility() == 0) {
if (this.animState == 1) {
return true;
}
return false;
} else if (this.animState != 2) {
return true;
} else {
return false;
}
}
private boolean shouldAnimateVisibilityChange() {
return ViewCompat.isLaidOut(this) && !isInEditMode();
}
/* access modifiers changed from: package-private */
public int getCollapsedSize() {
return (Math.min(ViewCompat.getPaddingStart(this), ViewCompat.getPaddingEnd(this)) * 2) + getIconSize();
}
protected static class ExtendedFloatingActionButtonBehavior<T extends ExtendedFloatingActionButton> extends CoordinatorLayout.Behavior<T> {
private static final boolean AUTO_HIDE_DEFAULT = false;
private static final boolean AUTO_SHRINK_DEFAULT = true;
private boolean autoHideEnabled;
private boolean autoShrinkEnabled;
private OnChangedCallback internalAutoHideCallback;
private OnChangedCallback internalAutoShrinkCallback;
private Rect tmpRect;
public ExtendedFloatingActionButtonBehavior() {
this.autoHideEnabled = false;
this.autoShrinkEnabled = true;
}
public ExtendedFloatingActionButtonBehavior(Context context, AttributeSet attributeSet) {
super(context, attributeSet);
TypedArray obtainStyledAttributes = context.obtainStyledAttributes(attributeSet, R.styleable.ExtendedFloatingActionButton_Behavior_Layout);
this.autoHideEnabled = obtainStyledAttributes.getBoolean(R.styleable.ExtendedFloatingActionButton_Behavior_Layout_behavior_autoHide, false);
this.autoShrinkEnabled = obtainStyledAttributes.getBoolean(R.styleable.ExtendedFloatingActionButton_Behavior_Layout_behavior_autoShrink, true);
obtainStyledAttributes.recycle();
}
public void setAutoHideEnabled(boolean z) {
this.autoHideEnabled = z;
}
public boolean isAutoHideEnabled() {
return this.autoHideEnabled;
}
public void setAutoShrinkEnabled(boolean z) {
this.autoShrinkEnabled = z;
}
public boolean isAutoShrinkEnabled() {
return this.autoShrinkEnabled;
}
public void onAttachedToLayoutParams(CoordinatorLayout.LayoutParams layoutParams) {
if (layoutParams.dodgeInsetEdges == 0) {
layoutParams.dodgeInsetEdges = 80;
}
}
public boolean onDependentViewChanged(CoordinatorLayout coordinatorLayout, ExtendedFloatingActionButton extendedFloatingActionButton, View view) {
if (view instanceof AppBarLayout) {
updateFabVisibilityForAppBarLayout(coordinatorLayout, (AppBarLayout) view, extendedFloatingActionButton);
return false;
} else if (!isBottomSheet(view)) {
return false;
} else {
updateFabVisibilityForBottomSheet(view, extendedFloatingActionButton);
return false;
}
}
private static boolean isBottomSheet(View view) {
ViewGroup.LayoutParams layoutParams = view.getLayoutParams();
if (layoutParams instanceof CoordinatorLayout.LayoutParams) {
return ((CoordinatorLayout.LayoutParams) layoutParams).getBehavior() instanceof BottomSheetBehavior;
}
return false;
}
/* access modifiers changed from: package-private */
public void setInternalAutoHideCallback(OnChangedCallback onChangedCallback) {
this.internalAutoHideCallback = onChangedCallback;
}
/* access modifiers changed from: package-private */
public void setInternalAutoShrinkCallback(OnChangedCallback onChangedCallback) {
this.internalAutoShrinkCallback = onChangedCallback;
}
private boolean shouldUpdateVisibility(View view, ExtendedFloatingActionButton extendedFloatingActionButton) {
CoordinatorLayout.LayoutParams layoutParams = (CoordinatorLayout.LayoutParams) extendedFloatingActionButton.getLayoutParams();
if ((this.autoHideEnabled || this.autoShrinkEnabled) && layoutParams.getAnchorId() == view.getId()) {
return true;
}
return false;
}
private boolean updateFabVisibilityForAppBarLayout(CoordinatorLayout coordinatorLayout, AppBarLayout appBarLayout, ExtendedFloatingActionButton extendedFloatingActionButton) {
if (!shouldUpdateVisibility(appBarLayout, extendedFloatingActionButton)) {
return false;
}
if (this.tmpRect == null) {
this.tmpRect = new Rect();
}
Rect rect = this.tmpRect;
DescendantOffsetUtils.getDescendantRect(coordinatorLayout, appBarLayout, rect);
if (rect.bottom <= appBarLayout.getMinimumHeightForVisibleOverlappingContent()) {
shrinkOrHide(extendedFloatingActionButton);
return true;
}
extendOrShow(extendedFloatingActionButton);
return true;
}
private boolean updateFabVisibilityForBottomSheet(View view, ExtendedFloatingActionButton extendedFloatingActionButton) {
if (!shouldUpdateVisibility(view, extendedFloatingActionButton)) {
return false;
}
if (view.getTop() < (extendedFloatingActionButton.getHeight() / 2) + ((CoordinatorLayout.LayoutParams) extendedFloatingActionButton.getLayoutParams()).topMargin) {
shrinkOrHide(extendedFloatingActionButton);
return true;
}
extendOrShow(extendedFloatingActionButton);
return true;
}
/* access modifiers changed from: protected */
public void shrinkOrHide(ExtendedFloatingActionButton extendedFloatingActionButton) {
MotionStrategy motionStrategy;
boolean z = this.autoShrinkEnabled;
OnChangedCallback onChangedCallback = z ? this.internalAutoShrinkCallback : this.internalAutoHideCallback;
if (z) {
motionStrategy = extendedFloatingActionButton.shrinkStrategy;
} else {
motionStrategy = extendedFloatingActionButton.hideStrategy;
}
extendedFloatingActionButton.performMotion(motionStrategy, onChangedCallback);
}
/* access modifiers changed from: protected */
public void extendOrShow(ExtendedFloatingActionButton extendedFloatingActionButton) {
MotionStrategy motionStrategy;
boolean z = this.autoShrinkEnabled;
OnChangedCallback onChangedCallback = z ? this.internalAutoShrinkCallback : this.internalAutoHideCallback;
if (z) {
motionStrategy = extendedFloatingActionButton.extendStrategy;
} else {
motionStrategy = extendedFloatingActionButton.showStrategy;
}
extendedFloatingActionButton.performMotion(motionStrategy, onChangedCallback);
}
public boolean onLayoutChild(CoordinatorLayout coordinatorLayout, ExtendedFloatingActionButton extendedFloatingActionButton, int i) {
List<View> dependencies = coordinatorLayout.getDependencies(extendedFloatingActionButton);
int size = dependencies.size();
for (int i2 = 0; i2 < size; i2++) {
View view = dependencies.get(i2);
if (!(view instanceof AppBarLayout)) {
if (isBottomSheet(view) && updateFabVisibilityForBottomSheet(view, extendedFloatingActionButton)) {
break;
}
} else if (updateFabVisibilityForAppBarLayout(coordinatorLayout, (AppBarLayout) view, extendedFloatingActionButton)) {
break;
}
}
coordinatorLayout.onLayoutChild(extendedFloatingActionButton, i);
offsetIfNeeded(coordinatorLayout, extendedFloatingActionButton);
return true;
}
public boolean getInsetDodgeRect(CoordinatorLayout coordinatorLayout, ExtendedFloatingActionButton extendedFloatingActionButton, Rect rect) {
Rect access$500 = extendedFloatingActionButton.shadowPadding;
rect.set(extendedFloatingActionButton.getLeft() + access$500.left, extendedFloatingActionButton.getTop() + access$500.top, extendedFloatingActionButton.getRight() - access$500.right, extendedFloatingActionButton.getBottom() - access$500.bottom);
return true;
}
private void offsetIfNeeded(CoordinatorLayout coordinatorLayout, ExtendedFloatingActionButton extendedFloatingActionButton) {
int i;
Rect access$500 = extendedFloatingActionButton.shadowPadding;
if (access$500 != null && access$500.centerX() > 0 && access$500.centerY() > 0) {
CoordinatorLayout.LayoutParams layoutParams = (CoordinatorLayout.LayoutParams) extendedFloatingActionButton.getLayoutParams();
int i2 = 0;
if (extendedFloatingActionButton.getRight() >= coordinatorLayout.getWidth() - layoutParams.rightMargin) {
i = access$500.right;
} else {
i = extendedFloatingActionButton.getLeft() <= layoutParams.leftMargin ? -access$500.left : 0;
}
if (extendedFloatingActionButton.getBottom() >= coordinatorLayout.getHeight() - layoutParams.bottomMargin) {
i2 = access$500.bottom;
} else if (extendedFloatingActionButton.getTop() <= layoutParams.topMargin) {
i2 = -access$500.top;
}
if (i2 != 0) {
ViewCompat.offsetTopAndBottom(extendedFloatingActionButton, i2);
}
if (i != 0) {
ViewCompat.offsetLeftAndRight(extendedFloatingActionButton, i);
}
}
}
}
class ChangeSizeStrategy extends BaseMotionStrategy {
private final boolean extending;
private final Size size;
ChangeSizeStrategy(AnimatorTracker animatorTracker, Size size2, boolean z) {
super(ExtendedFloatingActionButton.this, animatorTracker);
this.size = size2;
this.extending = z;
}
public void performNow() {
boolean unused = ExtendedFloatingActionButton.this.isExtended = this.extending;
ViewGroup.LayoutParams layoutParams = ExtendedFloatingActionButton.this.getLayoutParams();
if (layoutParams != null) {
if (this.extending) {
ExtendedFloatingActionButton.this.measure(0, 0);
}
layoutParams.width = this.size.getWidth();
layoutParams.height = this.size.getHeight();
ExtendedFloatingActionButton.this.requestLayout();
}
}
public void onChange(OnChangedCallback onChangedCallback) {
if (onChangedCallback != null) {
if (this.extending) {
onChangedCallback.onExtended(ExtendedFloatingActionButton.this);
} else {
onChangedCallback.onShrunken(ExtendedFloatingActionButton.this);
}
}
}
public int getDefaultMotionSpecResource() {
return R.animator.mtrl_extended_fab_change_size_motion_spec;
}
public AnimatorSet createAnimator() {
MotionSpec currentMotionSpec = getCurrentMotionSpec();
if (currentMotionSpec.hasPropertyValues("width")) {
PropertyValuesHolder[] propertyValues = currentMotionSpec.getPropertyValues("width");
propertyValues[0].setFloatValues(new float[]{(float) ExtendedFloatingActionButton.this.getWidth(), (float) this.size.getWidth()});
currentMotionSpec.setPropertyValues("width", propertyValues);
}
if (currentMotionSpec.hasPropertyValues("height")) {
PropertyValuesHolder[] propertyValues2 = currentMotionSpec.getPropertyValues("height");
propertyValues2[0].setFloatValues(new float[]{(float) ExtendedFloatingActionButton.this.getHeight(), (float) this.size.getHeight()});
currentMotionSpec.setPropertyValues("height", propertyValues2);
}
return super.createAnimator(currentMotionSpec);
}
public void onAnimationStart(Animator animator) {
super.onAnimationStart(animator);
boolean unused = ExtendedFloatingActionButton.this.isExtended = this.extending;
ExtendedFloatingActionButton.this.setHorizontallyScrolling(true);
}
public void onAnimationEnd() {
super.onAnimationEnd();
ExtendedFloatingActionButton.this.setHorizontallyScrolling(false);
}
public boolean shouldCancel() {
return this.extending == ExtendedFloatingActionButton.this.isExtended || ExtendedFloatingActionButton.this.getIcon() == null || TextUtils.isEmpty(ExtendedFloatingActionButton.this.getText());
}
}
class ShowStrategy extends BaseMotionStrategy {
public ShowStrategy(AnimatorTracker animatorTracker) {
super(ExtendedFloatingActionButton.this, animatorTracker);
}
public void performNow() {
ExtendedFloatingActionButton.this.setVisibility(0);
ExtendedFloatingActionButton.this.setAlpha(1.0f);
ExtendedFloatingActionButton.this.setScaleY(1.0f);
ExtendedFloatingActionButton.this.setScaleX(1.0f);
}
public void onChange(OnChangedCallback onChangedCallback) {
if (onChangedCallback != null) {
onChangedCallback.onShown(ExtendedFloatingActionButton.this);
}
}
public int getDefaultMotionSpecResource() {
return R.animator.mtrl_extended_fab_show_motion_spec;
}
public void onAnimationStart(Animator animator) {
super.onAnimationStart(animator);
ExtendedFloatingActionButton.this.setVisibility(0);
int unused = ExtendedFloatingActionButton.this.animState = 2;
}
public void onAnimationEnd() {
super.onAnimationEnd();
int unused = ExtendedFloatingActionButton.this.animState = 0;
}
public boolean shouldCancel() {
return ExtendedFloatingActionButton.this.isOrWillBeShown();
}
}
class HideStrategy extends BaseMotionStrategy {
private boolean isCancelled;
public HideStrategy(AnimatorTracker animatorTracker) {
super(ExtendedFloatingActionButton.this, animatorTracker);
}
public void performNow() {
ExtendedFloatingActionButton.this.setVisibility(8);
}
public void onChange(OnChangedCallback onChangedCallback) {
if (onChangedCallback != null) {
onChangedCallback.onHidden(ExtendedFloatingActionButton.this);
}
}
public boolean shouldCancel() {
return ExtendedFloatingActionButton.this.isOrWillBeHidden();
}
public int getDefaultMotionSpecResource() {
return R.animator.mtrl_extended_fab_hide_motion_spec;
}
public void onAnimationStart(Animator animator) {
super.onAnimationStart(animator);
this.isCancelled = false;
ExtendedFloatingActionButton.this.setVisibility(0);
int unused = ExtendedFloatingActionButton.this.animState = 1;
}
public void onAnimationCancel() {
super.onAnimationCancel();
this.isCancelled = true;
}
public void onAnimationEnd() {
super.onAnimationEnd();
int unused = ExtendedFloatingActionButton.this.animState = 0;
if (!this.isCancelled) {
ExtendedFloatingActionButton.this.setVisibility(8);
}
}
}
}
Download file