endVals = endValues.values;
+ final CharSequence startText = startVals.get(PROPNAME_TEXT) != null ?
+ (CharSequence) startVals.get(PROPNAME_TEXT) : "";
+ final CharSequence endText = endVals.get(PROPNAME_TEXT) != null ?
+ (CharSequence) endVals.get(PROPNAME_TEXT) : "";
+ final int startSelectionStart, startSelectionEnd, endSelectionStart, endSelectionEnd;
+ if (view instanceof EditText) {
+ startSelectionStart = startVals.get(PROPNAME_TEXT_SELECTION_START) != null ?
+ (Integer) startVals.get(PROPNAME_TEXT_SELECTION_START) : -1;
+ startSelectionEnd = startVals.get(PROPNAME_TEXT_SELECTION_END) != null ?
+ (Integer) startVals.get(PROPNAME_TEXT_SELECTION_END) : startSelectionStart;
+ endSelectionStart = endVals.get(PROPNAME_TEXT_SELECTION_START) != null ?
+ (Integer) endVals.get(PROPNAME_TEXT_SELECTION_START) : -1;
+ endSelectionEnd = endVals.get(PROPNAME_TEXT_SELECTION_END) != null ?
+ (Integer) endVals.get(PROPNAME_TEXT_SELECTION_END) : endSelectionStart;
+ } else {
+ startSelectionStart = startSelectionEnd = endSelectionStart = endSelectionEnd = -1;
+ }
+ if (!Objects.equals(startText, endText)) {
+ final int startColor;
+ final int endColor;
+ if (mChangeBehavior != CHANGE_BEHAVIOR_IN) {
+ view.setText(startText);
+ if (view instanceof EditText) {
+ setSelection(((EditText) view), startSelectionStart, startSelectionEnd);
+ }
+ }
+ Animator anim;
+ if (mChangeBehavior == CHANGE_BEHAVIOR_KEEP) {
+ startColor = endColor = 0;
+ anim = ValueAnimator.ofFloat(0, 1);
+ anim.addListener(new AnimatorListenerAdapter() {
+ @Override
+ public void onAnimationEnd(Animator animation) {
+ if (Objects.equals(startText, view.getText())) {
+ // Only set if it hasn't been changed since anim started
+ view.setText(endText);
+ if (view instanceof EditText) {
+ setSelection(((EditText) view), endSelectionStart, endSelectionEnd);
+ }
+ }
+ }
+ });
+ } else {
+ startColor = (Integer) startVals.get(PROPNAME_TEXT_COLOR);
+ endColor = (Integer) endVals.get(PROPNAME_TEXT_COLOR);
+ // Fade out start text
+ ValueAnimator outAnim = null, inAnim = null;
+ if (mChangeBehavior == CHANGE_BEHAVIOR_OUT_IN ||
+ mChangeBehavior == CHANGE_BEHAVIOR_OUT) {
+ outAnim = ValueAnimator.ofInt(Color.alpha(startColor), 0);
+ outAnim.addUpdateListener(animation -> {
+ int currAlpha = (Integer) animation.getAnimatedValue();
+ view.setTextColor(currAlpha << 24 | startColor & 0xffffff);
+ });
+ outAnim.addListener(new AnimatorListenerAdapter() {
+ @Override
+ public void onAnimationEnd(Animator animation) {
+ if (Objects.equals(startText, view.getText())) {
+ // Only set if it hasn't been changed since anim started
+ view.setText(endText);
+ if (view instanceof EditText) {
+ setSelection(((EditText) view), endSelectionStart,
+ endSelectionEnd);
+ }
+ }
+ // restore opaque alpha and correct end color
+ view.setTextColor(endColor);
+ }
+ });
+ }
+ if (mChangeBehavior == CHANGE_BEHAVIOR_OUT_IN ||
+ mChangeBehavior == CHANGE_BEHAVIOR_IN) {
+ inAnim = ValueAnimator.ofInt(0, Color.alpha(endColor));
+ inAnim.addUpdateListener(animation -> {
+ int currAlpha = (Integer) animation.getAnimatedValue();
+ view.setTextColor(currAlpha << 24 | endColor & 0xffffff);
+ });
+ inAnim.addListener(new AnimatorListenerAdapter() {
+ @Override
+ public void onAnimationCancel(Animator animation) {
+ // restore opaque alpha and correct end color
+ view.setTextColor(endColor);
+ }
+ });
+ }
+ if (outAnim != null && inAnim != null) {
+ anim = new AnimatorSet();
+ final AnimatorSet animatorSet = (AnimatorSet) anim;
+ if (crossFade) {
+ animatorSet.playTogether(outAnim, inAnim);
+ } else {
+ animatorSet.playSequentially(outAnim, inAnim);
+ }
+ } else if (outAnim != null) {
+ anim = outAnim;
+ } else {
+ // Must be an in-only animation
+ anim = inAnim;
+ }
+ }
+ TransitionListener transitionListener = new TransitionListenerAdapter() {
+ int mPausedColor = 0;
+
+ @Override
+ public void onTransitionPause(@NonNull Transition transition) {
+ if (mChangeBehavior != CHANGE_BEHAVIOR_IN) {
+ view.setText(endText);
+ if (view instanceof EditText) {
+ setSelection(((EditText) view), endSelectionStart, endSelectionEnd);
+ }
+ }
+ if (mChangeBehavior > CHANGE_BEHAVIOR_KEEP) {
+ mPausedColor = view.getCurrentTextColor();
+ view.setTextColor(endColor);
+ }
+ }
+
+ @Override
+ public void onTransitionResume(@NonNull Transition transition) {
+ if (mChangeBehavior != CHANGE_BEHAVIOR_IN) {
+ view.setText(startText);
+ if (view instanceof EditText) {
+ setSelection(((EditText) view), startSelectionStart, startSelectionEnd);
+ }
+ }
+ if (mChangeBehavior > CHANGE_BEHAVIOR_KEEP) {
+ view.setTextColor(mPausedColor);
+ }
+ }
+
+ @Override
+ public void onTransitionEnd(Transition transition) {
+ transition.removeListener(this);
+ }
+ };
+ addListener(transitionListener);
+ if (BuildConfig.DEBUG) {
+ Log.d(LOG_TAG, "createAnimator returning " + anim);
+ }
+ return anim;
+ }
+ return null;
+ }
+
+ private void setSelection(EditText editText, int start, int end) {
+ if (start >= 0 && end >= 0) {
+ editText.setSelection(start, end);
+ }
+ }
+}
diff --git a/app/src/main/java/awais/instagrabber/customviews/helpers/ControlFocusInsetsAnimationCallback.java b/app/src/main/java/awais/instagrabber/customviews/helpers/ControlFocusInsetsAnimationCallback.java
new file mode 100644
index 00000000..e1fda461
--- /dev/null
+++ b/app/src/main/java/awais/instagrabber/customviews/helpers/ControlFocusInsetsAnimationCallback.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package awais.instagrabber.customviews.helpers;
+
+import android.view.View;
+
+import androidx.annotation.NonNull;
+import androidx.core.view.ViewCompat;
+import androidx.core.view.WindowInsetsAnimationCompat;
+import androidx.core.view.WindowInsetsCompat;
+
+import java.util.List;
+
+/**
+ * A [WindowInsetsAnimationCompat.Callback] which will request and clear focus on the given view,
+ * depending on the [WindowInsetsCompat.Type.ime] visibility state when an IME
+ * [WindowInsetsAnimationCompat] has finished.
+ *
+ * This is primarily used when animating the [WindowInsetsCompat.Type.ime], so that the
+ * appropriate view is focused for accepting input from the IME.
+ */
+public class ControlFocusInsetsAnimationCallback extends WindowInsetsAnimationCompat.Callback {
+
+ private final View view;
+
+ public ControlFocusInsetsAnimationCallback(@NonNull final View view) {
+ this(view, DISPATCH_MODE_STOP);
+ }
+
+ /**
+ * @param view the view to request/clear focus
+ * @param dispatchMode The dispatch mode for this callback.
+ * @see WindowInsetsAnimationCompat.Callback.DispatchMode
+ */
+ public ControlFocusInsetsAnimationCallback(@NonNull final View view, final int dispatchMode) {
+ super(dispatchMode);
+ this.view = view;
+ }
+
+ @NonNull
+ @Override
+ public WindowInsetsCompat onProgress(@NonNull final WindowInsetsCompat insets,
+ @NonNull final List runningAnimations) {
+ // no-op and return the insets
+ return insets;
+ }
+
+ @Override
+ public void onEnd(final WindowInsetsAnimationCompat animation) {
+ if ((animation.getTypeMask() & WindowInsetsCompat.Type.ime()) != 0) {
+ // The animation has now finished, so we can check the view's focus state.
+ // We post the check because the rootWindowInsets has not yet been updated, but will
+ // be in the next message traversal
+ view.post(this::checkFocus);
+ }
+ }
+
+ private void checkFocus() {
+ final WindowInsetsCompat rootWindowInsets = ViewCompat.getRootWindowInsets(view);
+ boolean imeVisible = false;
+ if (rootWindowInsets != null) {
+ imeVisible = rootWindowInsets.isVisible(WindowInsetsCompat.Type.ime());
+ }
+ if (imeVisible && view.getRootView().findFocus() == null) {
+ // If the IME will be visible, and there is not a currently focused view in
+ // the hierarchy, request focus on our view
+ view.requestFocus();
+ } else if (!imeVisible && view.isFocused()) {
+ // If the IME will not be visible and our view is currently focused, clear the focus
+ view.clearFocus();
+ }
+ }
+}
diff --git a/app/src/main/java/awais/instagrabber/customviews/helpers/CustomHideBottomViewOnScrollBehavior.java b/app/src/main/java/awais/instagrabber/customviews/helpers/CustomHideBottomViewOnScrollBehavior.java
index 765fc679..dabc622b 100644
--- a/app/src/main/java/awais/instagrabber/customviews/helpers/CustomHideBottomViewOnScrollBehavior.java
+++ b/app/src/main/java/awais/instagrabber/customviews/helpers/CustomHideBottomViewOnScrollBehavior.java
@@ -1,5 +1,7 @@
package awais.instagrabber.customviews.helpers;
+import android.content.Context;
+import android.util.AttributeSet;
import android.view.View;
import androidx.annotation.NonNull;
@@ -12,6 +14,13 @@ import com.google.android.material.bottomnavigation.BottomNavigationView;
public class CustomHideBottomViewOnScrollBehavior extends HideBottomViewOnScrollBehavior {
private static final String TAG = "CustomHideBottomView";
+ public CustomHideBottomViewOnScrollBehavior() {
+ }
+
+ public CustomHideBottomViewOnScrollBehavior(final Context context, final AttributeSet attrs) {
+ super(context, attrs);
+ }
+
@Override
public boolean onStartNestedScroll(@NonNull final CoordinatorLayout coordinatorLayout,
@NonNull final BottomNavigationView child,
@@ -23,7 +32,13 @@ public class CustomHideBottomViewOnScrollBehavior extends HideBottomViewOnScroll
}
@Override
- public void onNestedPreScroll(@NonNull final CoordinatorLayout coordinatorLayout, @NonNull final BottomNavigationView child, @NonNull final View target, final int dx, final int dy, @NonNull final int[] consumed, final int type) {
+ public void onNestedPreScroll(@NonNull final CoordinatorLayout coordinatorLayout,
+ @NonNull final BottomNavigationView child,
+ @NonNull final View target,
+ final int dx,
+ final int dy,
+ @NonNull final int[] consumed,
+ final int type) {
if (dy > 0) {
slideDown(child);
} else if (dy < 0) {
diff --git a/app/src/main/java/awais/instagrabber/customviews/helpers/EmojiPickerInsetsAnimationCallback.java b/app/src/main/java/awais/instagrabber/customviews/helpers/EmojiPickerInsetsAnimationCallback.java
new file mode 100644
index 00000000..125b65c1
--- /dev/null
+++ b/app/src/main/java/awais/instagrabber/customviews/helpers/EmojiPickerInsetsAnimationCallback.java
@@ -0,0 +1,117 @@
+package awais.instagrabber.customviews.helpers;
+
+import android.view.View;
+import android.view.ViewGroup;
+
+import androidx.annotation.NonNull;
+import androidx.core.graphics.Insets;
+import androidx.core.view.ViewCompat;
+import androidx.core.view.WindowInsetsAnimationCompat;
+import androidx.core.view.WindowInsetsCompat;
+
+import java.util.List;
+
+/**
+ * A customized {@link TranslateDeferringInsetsAnimationCallback} for the emoji picker
+ */
+public class EmojiPickerInsetsAnimationCallback extends WindowInsetsAnimationCompat.Callback {
+ private static final String TAG = EmojiPickerInsetsAnimationCallback.class.getSimpleName();
+
+ private final View view;
+ private final int persistentInsetTypes;
+ private final int deferredInsetTypes;
+
+ private int kbHeight;
+ private onKbVisibilityChangeListener listener;
+ private boolean shouldTranslate;
+
+ public EmojiPickerInsetsAnimationCallback(final View view,
+ final int persistentInsetTypes,
+ final int deferredInsetTypes) {
+ this(view, persistentInsetTypes, deferredInsetTypes, DISPATCH_MODE_STOP);
+ }
+
+ public EmojiPickerInsetsAnimationCallback(final View view,
+ final int persistentInsetTypes,
+ final int deferredInsetTypes,
+ final int dispatchMode) {
+ super(dispatchMode);
+ if ((persistentInsetTypes & deferredInsetTypes) != 0) {
+ throw new IllegalArgumentException("persistentInsetTypes and deferredInsetTypes can not contain " +
+ "any of same WindowInsetsCompat.Type values");
+ }
+ this.view = view;
+ this.persistentInsetTypes = persistentInsetTypes;
+ this.deferredInsetTypes = deferredInsetTypes;
+ }
+
+ @NonNull
+ @Override
+ public WindowInsetsCompat onProgress(@NonNull final WindowInsetsCompat insets,
+ @NonNull final List runningAnimations) {
+ // onProgress() is called when any of the running animations progress...
+
+ // First we get the insets which are potentially deferred
+ final Insets typesInset = insets.getInsets(deferredInsetTypes);
+ // Then we get the persistent inset types which are applied as padding during layout
+ final Insets otherInset = insets.getInsets(persistentInsetTypes);
+
+ // Now that we subtract the two insets, to calculate the difference. We also coerce
+ // the insets to be >= 0, to make sure we don't use negative insets.
+ final Insets subtract = Insets.subtract(typesInset, otherInset);
+ final Insets diff = Insets.max(subtract, Insets.NONE);
+
+ // The resulting `diff` insets contain the values for us to apply as a translation
+ // to the view
+ view.setTranslationX(diff.left - diff.right);
+ view.setTranslationY(shouldTranslate ? diff.top - diff.bottom : -kbHeight);
+
+ return insets;
+ }
+
+ @Override
+ public void onEnd(@NonNull final WindowInsetsAnimationCompat animation) {
+ try {
+ final WindowInsetsCompat rootWindowInsets = ViewCompat.getRootWindowInsets(view);
+ if (kbHeight == 0) {
+ if (rootWindowInsets == null) return;
+ final Insets imeInsets = rootWindowInsets.getInsets(WindowInsetsCompat.Type.ime());
+ final Insets navBarInsets = rootWindowInsets.getInsets(WindowInsetsCompat.Type.navigationBars());
+ kbHeight = imeInsets.bottom - navBarInsets.bottom;
+ final ViewGroup.MarginLayoutParams layoutParams = (ViewGroup.MarginLayoutParams) view.getLayoutParams();
+ if (layoutParams != null) {
+ layoutParams.height = kbHeight;
+ layoutParams.setMargins(layoutParams.leftMargin, layoutParams.topMargin, layoutParams.rightMargin, -kbHeight);
+ }
+ }
+ view.setTranslationX(0f);
+ final boolean visible = rootWindowInsets != null && rootWindowInsets.isVisible(WindowInsetsCompat.Type.ime());
+ float translationY = 0;
+ if (!shouldTranslate) {
+ translationY = -kbHeight;
+ if (visible) {
+ translationY = 0;
+ }
+ }
+ view.setTranslationY(translationY);
+
+ if (listener != null && rootWindowInsets != null) {
+ listener.onChange(visible);
+ }
+ } finally {
+ shouldTranslate = true;
+ }
+ }
+
+ public void setShouldTranslate(final boolean shouldTranslate) {
+ this.shouldTranslate = shouldTranslate;
+ }
+
+ public void setKbVisibilityListener(final onKbVisibilityChangeListener listener) {
+ this.listener = listener;
+ }
+
+ public interface onKbVisibilityChangeListener {
+ void onChange(boolean isVisible);
+ }
+}
diff --git a/app/src/main/java/awais/instagrabber/customviews/helpers/GridSpacingItemDecoration.java b/app/src/main/java/awais/instagrabber/customviews/helpers/GridSpacingItemDecoration.java
index 81b4be92..f34c30f5 100755
--- a/app/src/main/java/awais/instagrabber/customviews/helpers/GridSpacingItemDecoration.java
+++ b/app/src/main/java/awais/instagrabber/customviews/helpers/GridSpacingItemDecoration.java
@@ -7,17 +7,24 @@ import androidx.annotation.NonNull;
import androidx.recyclerview.widget.RecyclerView;
public class GridSpacingItemDecoration extends RecyclerView.ItemDecoration {
- private final int spacing;
+ private final int halfSpace;
+
+ private boolean hasHeader;
public GridSpacingItemDecoration(int spacing) {
- this.spacing = spacing;
+ halfSpace = spacing / 2;
}
@Override
public void getItemOffsets(@NonNull Rect outRect, @NonNull View view, @NonNull RecyclerView parent, @NonNull RecyclerView.State state) {
- final int halfSpace = spacing / 2;
+ if (hasHeader && parent.getChildAdapterPosition(view) == 0) {
+ outRect.bottom = halfSpace;
+ outRect.left = -halfSpace;
+ outRect.right = -halfSpace;
+ return;
+ }
if (parent.getPaddingLeft() != halfSpace) {
- parent.setPadding(halfSpace, halfSpace, halfSpace, halfSpace);
+ parent.setPadding(halfSpace, hasHeader ? 0 : halfSpace, halfSpace, halfSpace);
parent.setClipToPadding(false);
}
outRect.top = halfSpace;
@@ -25,4 +32,8 @@ public class GridSpacingItemDecoration extends RecyclerView.ItemDecoration {
outRect.left = halfSpace;
outRect.right = halfSpace;
}
+
+ public void setHasHeader(final boolean hasHeader) {
+ this.hasHeader = hasHeader;
+ }
}
\ No newline at end of file
diff --git a/app/src/main/java/awais/instagrabber/customviews/helpers/RootViewDeferringInsetsCallback.java b/app/src/main/java/awais/instagrabber/customviews/helpers/RootViewDeferringInsetsCallback.java
new file mode 100644
index 00000000..f58be88a
--- /dev/null
+++ b/app/src/main/java/awais/instagrabber/customviews/helpers/RootViewDeferringInsetsCallback.java
@@ -0,0 +1,139 @@
+package awais.instagrabber.customviews.helpers;/*
+ * Copyright 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import android.view.View;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.core.graphics.Insets;
+import androidx.core.view.OnApplyWindowInsetsListener;
+import androidx.core.view.ViewCompat;
+import androidx.core.view.WindowInsetsAnimationCompat;
+import androidx.core.view.WindowInsetsCompat;
+
+import java.util.List;
+
+/**
+ * A class which extends/implements both [WindowInsetsAnimationCompat.Callback] and
+ * [View.OnApplyWindowInsetsListener], which should be set on the root view in your layout.
+ *
+ * This class enables the root view is selectively defer handling any insets which match
+ * [deferredInsetTypes], to enable better looking [WindowInsetsAnimationCompat]s.
+ *
+ * An example is the following: when a [WindowInsetsAnimationCompat] is started, the system will dispatch
+ * a [WindowInsetsCompat] instance which contains the end state of the animation. For the scenario of
+ * the IME being animated in, that means that the insets contains the IME height. If the view's
+ * [View.OnApplyWindowInsetsListener] simply always applied the combination of
+ * [WindowInsetsCompat.Type.ime] and [WindowInsetsCompat.Type.systemBars] using padding, the viewport of any
+ * child views would then be smaller. This results in us animating a smaller (padded-in) view into
+ * a larger viewport. Visually, this results in the views looking clipped.
+ *
+ * This class allows us to implement a different strategy for the above scenario, by selectively
+ * deferring the [WindowInsetsCompat.Type.ime] insets until the [WindowInsetsAnimationCompat] is ended.
+ * For the above example, you would create a [RootViewDeferringInsetsCallback] like so:
+ *
+ * ```
+ * val callback = RootViewDeferringInsetsCallback(
+ * persistentInsetTypes = WindowInsetsCompat.Type.systemBars(),
+ * deferredInsetTypes = WindowInsetsCompat.Type.ime()
+ * )
+ * ```
+ *
+ * This class is not limited to just IME animations, and can work with any [WindowInsetsCompat.Type]s.
+ */
+public class RootViewDeferringInsetsCallback extends WindowInsetsAnimationCompat.Callback implements OnApplyWindowInsetsListener {
+
+ private final int persistentInsetTypes;
+ private final int deferredInsetTypes;
+ @Nullable
+ private View view = null;
+ @Nullable
+ private WindowInsetsCompat lastWindowInsets = null;
+ private boolean deferredInsets = false;
+
+ /**
+ * @param persistentInsetTypes the bitmask of any inset types which should always be handled
+ * through padding the attached view
+ * @param deferredInsetTypes the bitmask of insets types which should be deferred until after
+ * any related [WindowInsetsAnimationCompat]s have ended
+ */
+ public RootViewDeferringInsetsCallback(final int persistentInsetTypes, final int deferredInsetTypes) {
+ super(DISPATCH_MODE_CONTINUE_ON_SUBTREE);
+ if ((persistentInsetTypes & deferredInsetTypes) != 0) {
+ throw new IllegalArgumentException("persistentInsetTypes and deferredInsetTypes can not contain " +
+ "any of same WindowInsetsCompat.Type values");
+ }
+ this.persistentInsetTypes = persistentInsetTypes;
+ this.deferredInsetTypes = deferredInsetTypes;
+ }
+
+ @Override
+ public WindowInsetsCompat onApplyWindowInsets(@NonNull final View v, @NonNull final WindowInsetsCompat windowInsets) {
+ // Store the view and insets for us in onEnd() below
+ view = v;
+ lastWindowInsets = windowInsets;
+
+ final int types = deferredInsets
+ // When the deferred flag is enabled, we only use the systemBars() insets
+ ? persistentInsetTypes
+ // Otherwise we handle the combination of the the systemBars() and ime() insets
+ : persistentInsetTypes | deferredInsetTypes;
+
+ // Finally we apply the resolved insets by setting them as padding
+ final Insets typeInsets = windowInsets.getInsets(types);
+ v.setPadding(typeInsets.left, typeInsets.top, typeInsets.right, typeInsets.bottom);
+
+ // We return the new WindowInsetsCompat.CONSUMED to stop the insets being dispatched any
+ // further into the view hierarchy. This replaces the deprecated
+ // WindowInsetsCompat.consumeSystemWindowInsets() and related functions.
+ return WindowInsetsCompat.CONSUMED;
+ }
+
+ @Override
+ public void onPrepare(WindowInsetsAnimationCompat animation) {
+ if ((animation.getTypeMask() & deferredInsetTypes) != 0) {
+ // We defer the WindowInsetsCompat.Type.ime() insets if the IME is currently not visible.
+ // This results in only the WindowInsetsCompat.Type.systemBars() being applied, allowing
+ // the scrolling view to remain at it's larger size.
+ deferredInsets = true;
+ }
+ }
+
+ @NonNull
+ @Override
+ public WindowInsetsCompat onProgress(@NonNull final WindowInsetsCompat insets,
+ @NonNull final List runningAnims) {
+ // This is a no-op. We don't actually want to handle any WindowInsetsAnimations
+ return insets;
+ }
+
+ @Override
+ public void onEnd(@NonNull final WindowInsetsAnimationCompat animation) {
+ if (deferredInsets && (animation.getTypeMask() & deferredInsetTypes) != 0) {
+ // If we deferred the IME insets and an IME animation has finished, we need to reset
+ // the flag
+ deferredInsets = false;
+
+ // And finally dispatch the deferred insets to the view now.
+ // Ideally we would just call view.requestApplyInsets() and let the normal dispatch
+ // cycle happen, but this happens too late resulting in a visual flicker.
+ // Instead we manually dispatch the most recent WindowInsets to the view.
+ if (lastWindowInsets != null && view != null) {
+ ViewCompat.dispatchApplyWindowInsets(view, lastWindowInsets);
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/app/src/main/java/awais/instagrabber/customviews/helpers/SimpleImeAnimationController.java b/app/src/main/java/awais/instagrabber/customviews/helpers/SimpleImeAnimationController.java
new file mode 100644
index 00000000..9bcc24d8
--- /dev/null
+++ b/app/src/main/java/awais/instagrabber/customviews/helpers/SimpleImeAnimationController.java
@@ -0,0 +1,443 @@
+/*
+ * Copyright 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package awais.instagrabber.customviews.helpers;
+
+import android.os.CancellationSignal;
+import android.util.Log;
+import android.view.View;
+import android.view.animation.LinearInterpolator;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.core.graphics.Insets;
+import androidx.core.view.ViewCompat;
+import androidx.core.view.WindowInsetsAnimationControlListenerCompat;
+import androidx.core.view.WindowInsetsAnimationControllerCompat;
+import androidx.core.view.WindowInsetsCompat;
+import androidx.core.view.WindowInsetsControllerCompat;
+import androidx.dynamicanimation.animation.FloatPropertyCompat;
+import androidx.dynamicanimation.animation.SpringAnimation;
+import androidx.dynamicanimation.animation.SpringForce;
+
+import awais.instagrabber.utils.ViewUtils;
+
+/**
+ * A wrapper around the [WindowInsetsAnimationControllerCompat] APIs in AndroidX Core, to simplify
+ * the implementation of common use-cases around the IME.
+ *
+ * See [InsetsAnimationLinearLayout] and [InsetsAnimationTouchListener] for examples of how
+ * to use this class.
+ */
+public class SimpleImeAnimationController {
+ private static final String TAG = SimpleImeAnimationController.class.getSimpleName();
+ /**
+ * Scroll threshold for determining whether to animating to the end state, or to the start state.
+ * Currently 15% of the total swipe distance distance
+ */
+ private static final float SCROLL_THRESHOLD = 0.15f;
+
+ @Nullable
+ private WindowInsetsAnimationControllerCompat insetsAnimationController = null;
+ @Nullable
+ private CancellationSignal pendingRequestCancellationSignal = null;
+ @Nullable
+ private OnRequestReadyListener pendingRequestOnReadyListener;
+ /**
+ * True if the IME was shown at the start of the current animation.
+ */
+ private boolean isImeShownAtStart = false;
+ @Nullable
+ private SpringAnimation currentSpringAnimation = null;
+ private WindowInsetsAnimationControlListenerCompat fwdListener;
+
+ /**
+ * A LinearInterpolator instance we can re-use across listeners.
+ */
+ private final LinearInterpolator linearInterpolator = new LinearInterpolator();
+ /* To take control of the an WindowInsetsAnimation, we need to pass in a listener to
+ controlWindowInsetsAnimation() in startControlRequest(). The listener created here
+ keeps track of the current WindowInsetsAnimationController and resets our state. */
+ private final WindowInsetsAnimationControlListenerCompat animationControlListener = new WindowInsetsAnimationControlListenerCompat() {
+ /**
+ * Once the request is ready, call our [onRequestReady] function
+ */
+ @Override
+ public void onReady(@NonNull final WindowInsetsAnimationControllerCompat controller, final int types) {
+ onRequestReady(controller);
+ if (fwdListener != null) {
+ fwdListener.onReady(controller, types);
+ }
+ }
+
+ /**
+ * If the request is finished, we should reset our internal state
+ */
+ @Override
+ public void onFinished(@NonNull final WindowInsetsAnimationControllerCompat controller) {
+ reset();
+ if (fwdListener != null) {
+ fwdListener.onFinished(controller);
+ }
+ }
+
+ /**
+ * If the request is cancelled, we should reset our internal state
+ */
+ @Override
+ public void onCancelled(@Nullable final WindowInsetsAnimationControllerCompat controller) {
+ reset();
+ if (fwdListener != null) {
+ fwdListener.onCancelled(controller);
+ }
+ }
+ };
+
+ /**
+ * Start a control request to the [view]s [android.view.WindowInsetsController]. This should
+ * be called once the view is in a position to take control over the position of the IME.
+ *
+ * @param view The view which is triggering this request
+ * @param onRequestReadyListener optional listener which will be called when the request is ready and
+ * the animation can proceed
+ */
+ public void startControlRequest(@NonNull final View view,
+ @Nullable final OnRequestReadyListener onRequestReadyListener) {
+ if (isInsetAnimationInProgress()) {
+ Log.w(TAG, "startControlRequest: Animation in progress. Can not start a new request to controlWindowInsetsAnimation()");
+ return;
+ }
+
+ // Keep track of the IME insets, and the IME visibility, at the start of the request
+ final WindowInsetsCompat rootWindowInsets = ViewCompat.getRootWindowInsets(view);
+ if (rootWindowInsets != null) {
+ isImeShownAtStart = rootWindowInsets.isVisible(WindowInsetsCompat.Type.ime());
+ }
+
+ // Create a cancellation signal, which we pass to controlWindowInsetsAnimation() below
+ pendingRequestCancellationSignal = new CancellationSignal();
+ // Keep reference to the onReady callback
+ pendingRequestOnReadyListener = onRequestReadyListener;
+
+ // Finally we make a controlWindowInsetsAnimation() request:
+ final WindowInsetsControllerCompat windowInsetsController = ViewCompat.getWindowInsetsController(view);
+ if (windowInsetsController != null) {
+ windowInsetsController.controlWindowInsetsAnimation(
+ // We're only catering for IME animations in this listener
+ WindowInsetsCompat.Type.ime(),
+ // Animation duration. This is not used by the system, and is only passed to any
+ // WindowInsetsAnimation.Callback set on views. We pass in -1 to indicate that we're
+ // not starting a finite animation, and that this is completely controlled by
+ // the user's touch.
+ -1,
+ // The time interpolator used in calculating the animation progress. The fraction value
+ // we passed into setInsetsAndAlpha() which be passed into this interpolator before
+ // being used by the system to inset the IME. LinearInterpolator is a good type
+ // to use for scrolling gestures.
+ linearInterpolator,
+ // A cancellation signal, which allows us to cancel the request to control
+ pendingRequestCancellationSignal,
+ // The WindowInsetsAnimationControlListener
+ animationControlListener
+ );
+ }
+ }
+
+ /**
+ * Start a control request to the [view]s [android.view.WindowInsetsController], similar to
+ * [startControlRequest], but immediately fling to a finish using [velocityY] once ready.
+ *
+ * This function is useful for fire-and-forget operations to animate the IME.
+ *
+ * @param view The view which is triggering this request
+ * @param velocityY the velocity of the touch gesture which caused this call
+ */
+ public void startAndFling(@NonNull final View view, final float velocityY) {
+ startControlRequest(view, null);
+ animateToFinish(velocityY);
+ }
+
+ /**
+ * Update the inset position of the IME by the given [dy] value. This value will be coerced
+ * into the hidden and shown inset values.
+ *
+ * This function should only be called if [isInsetAnimationInProgress] returns true.
+ *
+ * @return the amount of [dy] consumed by the inset animation, in pixels
+ */
+ public int insetBy(final int dy) {
+ if (insetsAnimationController == null) {
+ throw new IllegalStateException("Current WindowInsetsAnimationController is null." +
+ "This should only be called if isAnimationInProgress() returns true");
+ }
+ final WindowInsetsAnimationControllerCompat controller = insetsAnimationController;
+
+ // Call updateInsetTo() with the new inset value
+ return insetTo(controller.getCurrentInsets().bottom - dy);
+ }
+
+ /**
+ * Update the inset position of the IME to be the given [inset] value. This value will be
+ * coerced into the hidden and shown inset values.
+ *
+ * This function should only be called if [isInsetAnimationInProgress] returns true.
+ *
+ * @return the distance moved by the inset animation, in pixels
+ */
+ public int insetTo(final int inset) {
+ if (insetsAnimationController == null) {
+ throw new IllegalStateException("Current WindowInsetsAnimationController is null." +
+ "This should only be called if isAnimationInProgress() returns true");
+ }
+ final WindowInsetsAnimationControllerCompat controller = insetsAnimationController;
+
+ final int hiddenBottom = controller.getHiddenStateInsets().bottom;
+ final int shownBottom = controller.getShownStateInsets().bottom;
+ final int startBottom = isImeShownAtStart ? shownBottom : hiddenBottom;
+ final int endBottom = isImeShownAtStart ? hiddenBottom : shownBottom;
+
+ // We coerce the given inset within the limits of the hidden and shown insets
+ final int coercedBottom = coerceIn(inset, hiddenBottom, shownBottom);
+
+ final int consumedDy = controller.getCurrentInsets().bottom - coercedBottom;
+
+ // Finally update the insets in the WindowInsetsAnimationController using
+ // setInsetsAndAlpha().
+ controller.setInsetsAndAlpha(
+ // Here we update the animating insets. This is what controls where the IME is displayed.
+ // It is also passed through to views via their WindowInsetsAnimation.Callback.
+ Insets.of(0, 0, 0, coercedBottom),
+ // This controls the alpha value. We don't want to alter the alpha so use 1f
+ 1f,
+ // Finally we calculate the animation progress fraction. This value is passed through
+ // to any WindowInsetsAnimation.Callbacks, but it is not used by the system.
+ (coercedBottom - startBottom) / (float) (endBottom - startBottom)
+ );
+
+ return consumedDy;
+ }
+
+ /**
+ * Return `true` if an inset animation is in progress.
+ */
+ public boolean isInsetAnimationInProgress() {
+ return insetsAnimationController != null;
+ }
+
+ /**
+ * Return `true` if an inset animation is currently finishing.
+ */
+ public boolean isInsetAnimationFinishing() {
+ return currentSpringAnimation != null;
+ }
+
+ /**
+ * Return `true` if a request to control an inset animation is in progress.
+ */
+ public boolean isInsetAnimationRequestPending() {
+ return pendingRequestCancellationSignal != null;
+ }
+
+ /**
+ * Cancel the current [WindowInsetsAnimationControllerCompat]. We immediately finish
+ * the animation, reverting back to the state at the start of the gesture.
+ */
+ public void cancel() {
+ if (insetsAnimationController != null) {
+ insetsAnimationController.finish(isImeShownAtStart);
+ }
+ if (pendingRequestCancellationSignal != null) {
+ pendingRequestCancellationSignal.cancel();
+ }
+ if (currentSpringAnimation != null) {
+ // Cancel the current spring animation
+ currentSpringAnimation.cancel();
+ }
+ reset();
+ }
+
+ /**
+ * Finish the current [WindowInsetsAnimationControllerCompat] immediately.
+ */
+ public void finish() {
+ final WindowInsetsAnimationControllerCompat controller = insetsAnimationController;
+
+ if (controller == null) {
+ // If we don't currently have a controller, cancel any pending request and return
+ if (pendingRequestCancellationSignal != null) {
+ pendingRequestCancellationSignal.cancel();
+ }
+ return;
+ }
+
+ final int current = controller.getCurrentInsets().bottom;
+ final int shown = controller.getShownStateInsets().bottom;
+ final int hidden = controller.getHiddenStateInsets().bottom;
+
+ // The current inset matches either the shown/hidden inset, finish() immediately
+ if (current == shown) {
+ controller.finish(true);
+ } else if (current == hidden) {
+ controller.finish(false);
+ } else {
+ // Otherwise, we'll look at the current position...
+ if (controller.getCurrentFraction() >= SCROLL_THRESHOLD) {
+ // If the IME is past the 'threshold' we snap to the toggled state
+ controller.finish(!isImeShownAtStart);
+ } else {
+ // ...otherwise, we snap back to the original visibility
+ controller.finish(isImeShownAtStart);
+ }
+ }
+ }
+
+ /**
+ * Finish the current [WindowInsetsAnimationControllerCompat]. We finish the animation,
+ * animating to the end state if necessary.
+ *
+ * @param velocityY the velocity of the touch gesture which caused this call to [animateToFinish].
+ * Can be `null` if velocity is not available.
+ */
+ public void animateToFinish(@Nullable final Float velocityY) {
+ final WindowInsetsAnimationControllerCompat controller = insetsAnimationController;
+
+ if (controller == null) {
+ // If we don't currently have a controller, cancel any pending request and return
+ if (pendingRequestCancellationSignal != null) {
+ pendingRequestCancellationSignal.cancel();
+ }
+ return;
+ }
+
+ final int current = controller.getCurrentInsets().bottom;
+ final int shown = controller.getShownStateInsets().bottom;
+ final int hidden = controller.getHiddenStateInsets().bottom;
+
+ if (velocityY != null) {
+ // If we have a velocity, we can use it's direction to determine
+ // the visibility. Upwards == visible
+ animateImeToVisibility(velocityY > 0, velocityY);
+ } else if (current == shown) {
+ // The current inset matches either the shown/hidden inset, finish() immediately
+ controller.finish(true);
+ } else if (current == hidden) {
+ controller.finish(false);
+ } else {
+ // Otherwise, we'll look at the current position...
+ if (controller.getCurrentFraction() >= SCROLL_THRESHOLD) {
+ // If the IME is past the 'threshold' we animate it to the toggled state
+ animateImeToVisibility(!isImeShownAtStart, null);
+ } else {
+ // ...otherwise, we animate it back to the original visibility
+ animateImeToVisibility(isImeShownAtStart, null);
+ }
+ }
+ }
+
+ private void onRequestReady(@NonNull final WindowInsetsAnimationControllerCompat controller) {
+ // The request is ready, so clear out the pending cancellation signal
+ pendingRequestCancellationSignal = null;
+ // Store the current WindowInsetsAnimationController
+ insetsAnimationController = controller;
+
+ // Call any pending callback
+ if (pendingRequestOnReadyListener != null) {
+ pendingRequestOnReadyListener.onRequestReady(controller);
+ }
+ pendingRequestOnReadyListener = null;
+ }
+
+ /**
+ * Resets all of our internal state.
+ */
+ private void reset() {
+ // Clear all of our internal state
+ insetsAnimationController = null;
+ pendingRequestCancellationSignal = null;
+ isImeShownAtStart = false;
+ if (currentSpringAnimation != null) {
+ currentSpringAnimation.cancel();
+ }
+ currentSpringAnimation = null;
+ pendingRequestOnReadyListener = null;
+ }
+
+ /**
+ * Animate the IME to a given visibility.
+ *
+ * @param visible `true` to animate the IME to it's fully shown state, `false` to it's
+ * fully hidden state.
+ * @param velocityY the velocity of the touch gesture which caused this call. Can be `null`
+ * if velocity is not available.
+ */
+ private void animateImeToVisibility(final boolean visible, @Nullable final Float velocityY) {
+ if (insetsAnimationController == null) {
+ throw new IllegalStateException("Controller should not be null");
+ }
+ final WindowInsetsAnimationControllerCompat controller = insetsAnimationController;
+
+ final FloatPropertyCompat