src/com/android/launcher3/allapps/AllAppsFastScrollHelper.java - LeafOS-Project/android_packages_apps_Launcher3 - Gitiles

 /*
  * Copyright (C) 2015 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 com.android.launcher3.allapps;

 import com.android.launcher3.util.Thunk;

 import java.util.HashSet;
 import java.util.List;

 import androidx.recyclerview.widget.RecyclerView;

 public class AllAppsFastScrollHelper implements AllAppsGridAdapter.BindViewCallback {

     private static final int INITIAL_TOUCH_SETTLING_DURATION = 100;
     private static final int REPEAT_TOUCH_SETTLING_DURATION = 200;

     private AllAppsRecyclerView mRv;
     private AlphabeticalAppsList mApps;

     // Keeps track of the current and targeted fast scroll section (the section to scroll to after
     // the initial delay)
     int mTargetFastScrollPosition = -1;
     @Thunk String mCurrentFastScrollSection;
     @Thunk String mTargetFastScrollSection;

     // The settled states affect the delay before the fast scroll animation is applied
     private boolean mHasFastScrollTouchSettled;
     private boolean mHasFastScrollTouchSettledAtLeastOnce;

     // Set of all views animated during fast scroll.  We keep track of these ourselves since there
     // is no way to reset a view once it gets scrapped or recycled without other hacks
     private HashSet<RecyclerView.ViewHolder> mTrackedFastScrollViews = new HashSet<>();

     // Smooth fast-scroll animation frames
     @Thunk int mFastScrollFrameIndex;
     @Thunk final int[] mFastScrollFrames = new int[10];

     /**
      * This runnable runs a single frame of the smooth scroll animation and posts the next frame
      * if necessary.
      */
     @Thunk Runnable mSmoothSnapNextFrameRunnable = new Runnable() {
         @Override
         public void run() {
             if (mFastScrollFrameIndex < mFastScrollFrames.length) {
                 mRv.scrollBy(0, mFastScrollFrames[mFastScrollFrameIndex]);
                 mFastScrollFrameIndex++;
                 mRv.postOnAnimation(mSmoothSnapNextFrameRunnable);
             }
         }
     };

     /**
      * This runnable updates the current fast scroll section to the target fastscroll section.
      */
     Runnable mFastScrollToTargetSectionRunnable = new Runnable() {
         @Override
         public void run() {
             // Update to the target section
             mCurrentFastScrollSection = mTargetFastScrollSection;
             mHasFastScrollTouchSettled = true;
             mHasFastScrollTouchSettledAtLeastOnce = true;
             updateTrackedViewsFastScrollFocusState();
         }
     };

     public AllAppsFastScrollHelper(AllAppsRecyclerView rv, AlphabeticalAppsList apps) {
         mRv = rv;
         mApps = apps;
     }

     public void onSetAdapter(AllAppsGridAdapter adapter) {
         adapter.setBindViewCallback(this);
     }

     /**
      * Smooth scrolls the recycler view to the given section.
      *
      * @return whether the fastscroller can scroll to the new section.
      */
     public boolean smoothScrollToSection(int scrollY, int availableScrollHeight,
             AlphabeticalAppsList.FastScrollSectionInfo info) {
         if (mTargetFastScrollPosition != info.fastScrollToItem.position) {
             mTargetFastScrollPosition = info.fastScrollToItem.position;
             smoothSnapToPosition(scrollY, availableScrollHeight, info);
             return true;
         }
         return false;
     }

     /**
      * Smoothly snaps to a given position.  We do this manually by calculating the keyframes
      * ourselves and animating the scroll on the recycler view.
      */
     private void smoothSnapToPosition(int scrollY, int availableScrollHeight,
             AlphabeticalAppsList.FastScrollSectionInfo info) {
         mRv.removeCallbacks(mSmoothSnapNextFrameRunnable);
         mRv.removeCallbacks(mFastScrollToTargetSectionRunnable);

         trackAllChildViews();
         if (mHasFastScrollTouchSettled) {
             // In this case, the user has already settled once (and the fast scroll state has
             // animated) and they are just fine-tuning their section from the last section, so
             // we should make it feel fast and update immediately.
             mCurrentFastScrollSection = info.sectionName;
             mTargetFastScrollSection = null;
             updateTrackedViewsFastScrollFocusState();
         } else {
             // Otherwise, the user has scrubbed really far, and we don't want to distract the user
             // with the flashing fast scroll state change animation in addition to the fast scroll
             // section popup, so reset the views to normal, and wait for the touch to settle again
             // before animating the fast scroll state.
             mCurrentFastScrollSection = null;
             mTargetFastScrollSection = info.sectionName;
             mHasFastScrollTouchSettled = false;
             updateTrackedViewsFastScrollFocusState();

             // Delay scrolling to a new section until after some duration.  If the user has been
             // scrubbing a while and makes multiple big jumps, then reduce the time needed for the
             // fast scroll to settle so it doesn't feel so long.
             mRv.postDelayed(mFastScrollToTargetSectionRunnable,
                     mHasFastScrollTouchSettledAtLeastOnce ?
                             REPEAT_TOUCH_SETTLING_DURATION :
                             INITIAL_TOUCH_SETTLING_DURATION);
         }

         // Calculate the full animation from the current scroll position to the final scroll
         // position, and then run the animation for the duration.  If we are scrolling to the
         // first fast scroll section, then just scroll to the top of the list itself.
         List<AlphabeticalAppsList.FastScrollSectionInfo> fastScrollSections =
                 mApps.getFastScrollerSections();
         int newPosition = info.fastScrollToItem.position;
         int newScrollY = fastScrollSections.size() > 0 && fastScrollSections.get(0) == info
                         ? 0
                         : Math.min(availableScrollHeight, mRv.getCurrentScrollY(newPosition, 0));
         int numFrames = mFastScrollFrames.length;
         int deltaY = newScrollY - scrollY;
         float ySign = Math.signum(deltaY);
         int step = (int) (ySign * Math.ceil((float) Math.abs(deltaY) / numFrames));
         for (int i = 0; i < numFrames; i++) {
             // TODO(winsonc): We can interpolate this as well.
             mFastScrollFrames[i] = (int) (ySign * Math.min(Math.abs(step), Math.abs(deltaY)));
             deltaY -= step;
         }
         mFastScrollFrameIndex = 0;
         mRv.postOnAnimation(mSmoothSnapNextFrameRunnable);
     }

     public void onFastScrollCompleted() {
         // TODO(winsonc): Handle the case when the user scrolls and releases before the animation
         //                runs

         // Stop animating the fast scroll position and state
         mRv.removeCallbacks(mSmoothSnapNextFrameRunnable);
         mRv.removeCallbacks(mFastScrollToTargetSectionRunnable);

         // Reset the tracking variables
         mHasFastScrollTouchSettled = false;
         mHasFastScrollTouchSettledAtLeastOnce = false;
         mCurrentFastScrollSection = null;
         mTargetFastScrollSection = null;
         mTargetFastScrollPosition = -1;

         updateTrackedViewsFastScrollFocusState();
         mTrackedFastScrollViews.clear();
     }

     @Override
     public void onBindView(AllAppsGridAdapter.ViewHolder holder) {
         // Update newly bound views to the current fast scroll state if we are fast scrolling
         if (mCurrentFastScrollSection != null || mTargetFastScrollSection != null) {
             mTrackedFastScrollViews.add(holder);
         }
     }

     /**
      * Starts tracking all the recycler view's children which are FastScrollFocusableViews.
      */
     private void trackAllChildViews() {
         int childCount = mRv.getChildCount();
         for (int i = 0; i < childCount; i++) {
             RecyclerView.ViewHolder viewHolder = mRv.getChildViewHolder(mRv.getChildAt(i));
             if (viewHolder != null) {
                 mTrackedFastScrollViews.add(viewHolder);
             }
         }
     }

     /**
      * Updates the fast scroll focus on all the children.
      */
     private void updateTrackedViewsFastScrollFocusState() {
         for (RecyclerView.ViewHolder viewHolder : mTrackedFastScrollViews) {
             int pos = viewHolder.getAdapterPosition();
             boolean isActive = false;
             if (mCurrentFastScrollSection != null
                     && pos > RecyclerView.NO_POSITION
                     && pos < mApps.getAdapterItems().size()) {
                 AlphabeticalAppsList.AdapterItem item = mApps.getAdapterItems().get(pos);
                 isActive = item != null &&
                         mCurrentFastScrollSection.equals(item.sectionName) &&
                         item.position == mTargetFastScrollPosition;
             }
             viewHolder.itemView.setActivated(isActive);
         }
     }
 }
	/*
	* Copyright (C) 2015 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 com.android.launcher3.allapps;

	import com.android.launcher3.util.Thunk;

	import java.util.HashSet;
	import java.util.List;

	import androidx.recyclerview.widget.RecyclerView;

	public class AllAppsFastScrollHelper implements AllAppsGridAdapter.BindViewCallback {

	private static final int INITIAL_TOUCH_SETTLING_DURATION = 100;
	private static final int REPEAT_TOUCH_SETTLING_DURATION = 200;

	private AllAppsRecyclerView mRv;
	private AlphabeticalAppsList mApps;

	// Keeps track of the current and targeted fast scroll section (the section to scroll to after
	// the initial delay)
	int mTargetFastScrollPosition = -1;
	@Thunk String mCurrentFastScrollSection;
	@Thunk String mTargetFastScrollSection;

	// The settled states affect the delay before the fast scroll animation is applied
	private boolean mHasFastScrollTouchSettled;
	private boolean mHasFastScrollTouchSettledAtLeastOnce;

	// Set of all views animated during fast scroll. We keep track of these ourselves since there
	// is no way to reset a view once it gets scrapped or recycled without other hacks
	private HashSet<RecyclerView.ViewHolder> mTrackedFastScrollViews = new HashSet<>();

	// Smooth fast-scroll animation frames
	@Thunk int mFastScrollFrameIndex;
	@Thunk final int[] mFastScrollFrames = new int[10];

	/**
	* This runnable runs a single frame of the smooth scroll animation and posts the next frame
	* if necessary.
	*/
	@Thunk Runnable mSmoothSnapNextFrameRunnable = new Runnable() {
	@Override
	public void run() {
	if (mFastScrollFrameIndex < mFastScrollFrames.length) {
	mRv.scrollBy(0, mFastScrollFrames[mFastScrollFrameIndex]);
	mFastScrollFrameIndex++;
	mRv.postOnAnimation(mSmoothSnapNextFrameRunnable);
	}
	}
	};

	/**
	* This runnable updates the current fast scroll section to the target fastscroll section.
	*/
	Runnable mFastScrollToTargetSectionRunnable = new Runnable() {
	@Override
	public void run() {
	// Update to the target section
	mCurrentFastScrollSection = mTargetFastScrollSection;
	mHasFastScrollTouchSettled = true;
	mHasFastScrollTouchSettledAtLeastOnce = true;
	updateTrackedViewsFastScrollFocusState();
	}
	};

	public AllAppsFastScrollHelper(AllAppsRecyclerView rv, AlphabeticalAppsList apps) {
	mRv = rv;
	mApps = apps;
	}

	public void onSetAdapter(AllAppsGridAdapter adapter) {
	adapter.setBindViewCallback(this);
	}

	/**
	* Smooth scrolls the recycler view to the given section.
	*
	* @return whether the fastscroller can scroll to the new section.
	*/
	public boolean smoothScrollToSection(int scrollY, int availableScrollHeight,
	AlphabeticalAppsList.FastScrollSectionInfo info) {
	if (mTargetFastScrollPosition != info.fastScrollToItem.position) {
	mTargetFastScrollPosition = info.fastScrollToItem.position;
	smoothSnapToPosition(scrollY, availableScrollHeight, info);
	return true;
	}
	return false;
	}

	/**
	* Smoothly snaps to a given position. We do this manually by calculating the keyframes
	* ourselves and animating the scroll on the recycler view.
	*/
	private void smoothSnapToPosition(int scrollY, int availableScrollHeight,
	AlphabeticalAppsList.FastScrollSectionInfo info) {
	mRv.removeCallbacks(mSmoothSnapNextFrameRunnable);
	mRv.removeCallbacks(mFastScrollToTargetSectionRunnable);

	trackAllChildViews();
	if (mHasFastScrollTouchSettled) {
	// In this case, the user has already settled once (and the fast scroll state has
	// animated) and they are just fine-tuning their section from the last section, so
	// we should make it feel fast and update immediately.
	mCurrentFastScrollSection = info.sectionName;
	mTargetFastScrollSection = null;
	updateTrackedViewsFastScrollFocusState();
	} else {
	// Otherwise, the user has scrubbed really far, and we don't want to distract the user
	// with the flashing fast scroll state change animation in addition to the fast scroll
	// section popup, so reset the views to normal, and wait for the touch to settle again
	// before animating the fast scroll state.
	mCurrentFastScrollSection = null;
	mTargetFastScrollSection = info.sectionName;
	mHasFastScrollTouchSettled = false;
	updateTrackedViewsFastScrollFocusState();

	// Delay scrolling to a new section until after some duration. If the user has been
	// scrubbing a while and makes multiple big jumps, then reduce the time needed for the
	// fast scroll to settle so it doesn't feel so long.
	mRv.postDelayed(mFastScrollToTargetSectionRunnable,
	mHasFastScrollTouchSettledAtLeastOnce ?
	REPEAT_TOUCH_SETTLING_DURATION :
	INITIAL_TOUCH_SETTLING_DURATION);
	}

	// Calculate the full animation from the current scroll position to the final scroll
	// position, and then run the animation for the duration. If we are scrolling to the
	// first fast scroll section, then just scroll to the top of the list itself.
	List<AlphabeticalAppsList.FastScrollSectionInfo> fastScrollSections =
	mApps.getFastScrollerSections();
	int newPosition = info.fastScrollToItem.position;
	int newScrollY = fastScrollSections.size() > 0 && fastScrollSections.get(0) == info
	? 0
	: Math.min(availableScrollHeight, mRv.getCurrentScrollY(newPosition, 0));
	int numFrames = mFastScrollFrames.length;
	int deltaY = newScrollY - scrollY;
	float ySign = Math.signum(deltaY);
	int step = (int) (ySign * Math.ceil((float) Math.abs(deltaY) / numFrames));
	for (int i = 0; i < numFrames; i++) {
	// TODO(winsonc): We can interpolate this as well.
	mFastScrollFrames[i] = (int) (ySign * Math.min(Math.abs(step), Math.abs(deltaY)));
	deltaY -= step;
	}
	mFastScrollFrameIndex = 0;
	mRv.postOnAnimation(mSmoothSnapNextFrameRunnable);
	}

	public void onFastScrollCompleted() {
	// TODO(winsonc): Handle the case when the user scrolls and releases before the animation
	// runs

	// Stop animating the fast scroll position and state
	mRv.removeCallbacks(mSmoothSnapNextFrameRunnable);
	mRv.removeCallbacks(mFastScrollToTargetSectionRunnable);

	// Reset the tracking variables
	mHasFastScrollTouchSettled = false;
	mHasFastScrollTouchSettledAtLeastOnce = false;
	mCurrentFastScrollSection = null;
	mTargetFastScrollSection = null;
	mTargetFastScrollPosition = -1;

	updateTrackedViewsFastScrollFocusState();
	mTrackedFastScrollViews.clear();
	}

	@Override
	public void onBindView(AllAppsGridAdapter.ViewHolder holder) {
	// Update newly bound views to the current fast scroll state if we are fast scrolling
	if (mCurrentFastScrollSection != null \|\| mTargetFastScrollSection != null) {
	mTrackedFastScrollViews.add(holder);
	}
	}

	/**
	* Starts tracking all the recycler view's children which are FastScrollFocusableViews.
	*/
	private void trackAllChildViews() {
	int childCount = mRv.getChildCount();
	for (int i = 0; i < childCount; i++) {
	RecyclerView.ViewHolder viewHolder = mRv.getChildViewHolder(mRv.getChildAt(i));
	if (viewHolder != null) {
	mTrackedFastScrollViews.add(viewHolder);
	}
	}
	}

	/**
	* Updates the fast scroll focus on all the children.
	*/
	private void updateTrackedViewsFastScrollFocusState() {
	for (RecyclerView.ViewHolder viewHolder : mTrackedFastScrollViews) {
	int pos = viewHolder.getAdapterPosition();
	boolean isActive = false;
	if (mCurrentFastScrollSection != null
	&& pos > RecyclerView.NO_POSITION
	&& pos < mApps.getAdapterItems().size()) {
	AlphabeticalAppsList.AdapterItem item = mApps.getAdapterItems().get(pos);
	isActive = item != null &&
	mCurrentFastScrollSection.equals(item.sectionName) &&
	item.position == mTargetFastScrollPosition;
	}
	viewHolder.itemView.setActivated(isActive);
	}
	}
	}