1 /* 2 * Copyright (C) 2015 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 package com.android.launcher3.allapps; 17 18 import android.content.Context; 19 import android.graphics.Canvas; 20 import android.os.Bundle; 21 import android.support.v7.widget.LinearLayoutManager; 22 import android.support.v7.widget.RecyclerView; 23 import android.util.AttributeSet; 24 import android.view.View; 25 26 import com.android.launcher3.BaseRecyclerView; 27 import com.android.launcher3.BaseRecyclerViewFastScrollBar; 28 import com.android.launcher3.DeviceProfile; 29 import com.android.launcher3.Stats; 30 import com.android.launcher3.Utilities; 31 import com.android.launcher3.util.Thunk; 32 33 import java.util.List; 34 35 /** 36 * A RecyclerView with custom fast scroll support for the all apps view. 37 */ 38 public class AllAppsRecyclerView extends BaseRecyclerView 39 implements Stats.LaunchSourceProvider { 40 41 private static final int FAST_SCROLL_MODE_JUMP_TO_FIRST_ICON = 0; 42 private static final int FAST_SCROLL_MODE_FREE_SCROLL = 1; 43 44 private static final int FAST_SCROLL_BAR_MODE_DISTRIBUTE_BY_ROW = 0; 45 private static final int FAST_SCROLL_BAR_MODE_DISTRIBUTE_BY_SECTIONS = 1; 46 47 private AlphabeticalAppsList mApps; 48 private int mNumAppsPerRow; 49 50 @Thunk BaseRecyclerViewFastScrollBar.FastScrollFocusableView mLastFastScrollFocusedView; 51 @Thunk int mPrevFastScrollFocusedPosition; 52 @Thunk int mFastScrollFrameIndex; 53 @Thunk final int[] mFastScrollFrames = new int[10]; 54 55 private final int mFastScrollMode = FAST_SCROLL_MODE_JUMP_TO_FIRST_ICON; 56 private final int mScrollBarMode = FAST_SCROLL_BAR_MODE_DISTRIBUTE_BY_ROW; 57 58 private ScrollPositionState mScrollPosState = new ScrollPositionState(); 59 60 public AllAppsRecyclerView(Context context) { 61 this(context, null); 62 } 63 64 public AllAppsRecyclerView(Context context, AttributeSet attrs) { 65 this(context, attrs, 0); 66 } 67 68 public AllAppsRecyclerView(Context context, AttributeSet attrs, int defStyleAttr) { 69 this(context, attrs, defStyleAttr, 0); 70 } 71 72 public AllAppsRecyclerView(Context context, AttributeSet attrs, int defStyleAttr, 73 int defStyleRes) { 74 super(context, attrs, defStyleAttr); 75 } 76 77 /** 78 * Sets the list of apps in this view, used to determine the fastscroll position. 79 */ 80 public void setApps(AlphabeticalAppsList apps) { 81 mApps = apps; 82 } 83 84 /** 85 * Sets the number of apps per row in this recycler view. 86 */ 87 public void setNumAppsPerRow(DeviceProfile grid, int numAppsPerRow) { 88 mNumAppsPerRow = numAppsPerRow; 89 90 RecyclerView.RecycledViewPool pool = getRecycledViewPool(); 91 int approxRows = (int) Math.ceil(grid.availableHeightPx / grid.allAppsIconSizePx); 92 pool.setMaxRecycledViews(AllAppsGridAdapter.EMPTY_SEARCH_VIEW_TYPE, 1); 93 pool.setMaxRecycledViews(AllAppsGridAdapter.ICON_VIEW_TYPE, approxRows * mNumAppsPerRow); 94 pool.setMaxRecycledViews(AllAppsGridAdapter.PREDICTION_ICON_VIEW_TYPE, mNumAppsPerRow); 95 pool.setMaxRecycledViews(AllAppsGridAdapter.SECTION_BREAK_VIEW_TYPE, approxRows); 96 } 97 98 /** 99 * Scrolls this recycler view to the top. 100 */ 101 public void scrollToTop() { 102 scrollToPosition(0); 103 } 104 105 /** 106 * We need to override the draw to ensure that we don't draw the overscroll effect beyond the 107 * background bounds. 108 */ 109 @Override 110 protected void dispatchDraw(Canvas canvas) { 111 canvas.clipRect(mBackgroundPadding.left, mBackgroundPadding.top, 112 getWidth() - mBackgroundPadding.right, 113 getHeight() - mBackgroundPadding.bottom); 114 super.dispatchDraw(canvas); 115 } 116 117 @Override 118 protected void onFinishInflate() { 119 super.onFinishInflate(); 120 121 // Bind event handlers 122 addOnItemTouchListener(this); 123 } 124 125 @Override 126 public void fillInLaunchSourceData(Bundle sourceData) { 127 sourceData.putString(Stats.SOURCE_EXTRA_CONTAINER, Stats.CONTAINER_ALL_APPS); 128 if (mApps.hasFilter()) { 129 sourceData.putString(Stats.SOURCE_EXTRA_SUB_CONTAINER, 130 Stats.SUB_CONTAINER_ALL_APPS_SEARCH); 131 } else { 132 sourceData.putString(Stats.SOURCE_EXTRA_SUB_CONTAINER, 133 Stats.SUB_CONTAINER_ALL_APPS_A_Z); 134 } 135 } 136 137 /** 138 * Maps the touch (from 0..1) to the adapter position that should be visible. 139 */ 140 @Override 141 public String scrollToPositionAtProgress(float touchFraction) { 142 int rowCount = mApps.getNumAppRows(); 143 if (rowCount == 0) { 144 return ""; 145 } 146 147 // Stop the scroller if it is scrolling 148 stopScroll(); 149 150 // Find the fastscroll section that maps to this touch fraction 151 List<AlphabeticalAppsList.FastScrollSectionInfo> fastScrollSections = 152 mApps.getFastScrollerSections(); 153 AlphabeticalAppsList.FastScrollSectionInfo lastInfo = fastScrollSections.get(0); 154 if (mScrollBarMode == FAST_SCROLL_BAR_MODE_DISTRIBUTE_BY_ROW) { 155 for (int i = 1; i < fastScrollSections.size(); i++) { 156 AlphabeticalAppsList.FastScrollSectionInfo info = fastScrollSections.get(i); 157 if (info.touchFraction > touchFraction) { 158 break; 159 } 160 lastInfo = info; 161 } 162 } else if (mScrollBarMode == FAST_SCROLL_BAR_MODE_DISTRIBUTE_BY_SECTIONS){ 163 lastInfo = fastScrollSections.get((int) (touchFraction * (fastScrollSections.size() - 1))); 164 } else { 165 throw new RuntimeException("Unexpected scroll bar mode"); 166 } 167 168 // Map the touch position back to the scroll of the recycler view 169 getCurScrollState(mScrollPosState, mApps.getAdapterItems()); 170 int availableScrollHeight = getAvailableScrollHeight(rowCount, mScrollPosState.rowHeight, 0); 171 LinearLayoutManager layoutManager = (LinearLayoutManager) getLayoutManager(); 172 if (mFastScrollMode == FAST_SCROLL_MODE_FREE_SCROLL) { 173 layoutManager.scrollToPositionWithOffset(0, (int) -(availableScrollHeight * touchFraction)); 174 } 175 176 if (mPrevFastScrollFocusedPosition != lastInfo.fastScrollToItem.position) { 177 mPrevFastScrollFocusedPosition = lastInfo.fastScrollToItem.position; 178 179 // Reset the last focused view 180 if (mLastFastScrollFocusedView != null) { 181 mLastFastScrollFocusedView.setFastScrollFocused(false, true); 182 mLastFastScrollFocusedView = null; 183 } 184 185 if (mFastScrollMode == FAST_SCROLL_MODE_JUMP_TO_FIRST_ICON) { 186 smoothSnapToPosition(mPrevFastScrollFocusedPosition, mScrollPosState); 187 } else if (mFastScrollMode == FAST_SCROLL_MODE_FREE_SCROLL) { 188 final ViewHolder vh = findViewHolderForPosition(mPrevFastScrollFocusedPosition); 189 if (vh != null && 190 vh.itemView instanceof BaseRecyclerViewFastScrollBar.FastScrollFocusableView) { 191 mLastFastScrollFocusedView = 192 (BaseRecyclerViewFastScrollBar.FastScrollFocusableView) vh.itemView; 193 mLastFastScrollFocusedView.setFastScrollFocused(true, true); 194 } 195 } else { 196 throw new RuntimeException("Unexpected fast scroll mode"); 197 } 198 } 199 return lastInfo.sectionName; 200 } 201 202 @Override 203 public void onFastScrollCompleted() { 204 super.onFastScrollCompleted(); 205 // Reset and clean up the last focused view 206 if (mLastFastScrollFocusedView != null) { 207 mLastFastScrollFocusedView.setFastScrollFocused(false, true); 208 mLastFastScrollFocusedView = null; 209 } 210 mPrevFastScrollFocusedPosition = -1; 211 } 212 213 /** 214 * Updates the bounds for the scrollbar. 215 */ 216 @Override 217 public void onUpdateScrollbar() { 218 List<AlphabeticalAppsList.AdapterItem> items = mApps.getAdapterItems(); 219 220 // Skip early if there are no items or we haven't been measured 221 if (items.isEmpty() || mNumAppsPerRow == 0) { 222 mScrollbar.setScrollbarThumbOffset(-1, -1); 223 return; 224 } 225 226 // Find the index and height of the first visible row (all rows have the same height) 227 int rowCount = mApps.getNumAppRows(); 228 getCurScrollState(mScrollPosState, items); 229 if (mScrollPosState.rowIndex < 0) { 230 mScrollbar.setScrollbarThumbOffset(-1, -1); 231 return; 232 } 233 234 synchronizeScrollBarThumbOffsetToViewScroll(mScrollPosState, rowCount, 0); 235 } 236 237 /** 238 * This runnable runs a single frame of the smooth scroll animation and posts the next frame 239 * if necessary. 240 */ 241 @Thunk Runnable mSmoothSnapNextFrameRunnable = new Runnable() { 242 @Override 243 public void run() { 244 if (mFastScrollFrameIndex < mFastScrollFrames.length) { 245 scrollBy(0, mFastScrollFrames[mFastScrollFrameIndex]); 246 mFastScrollFrameIndex++; 247 postOnAnimation(mSmoothSnapNextFrameRunnable); 248 } else { 249 // Animation completed, set the fast scroll state on the target view 250 final ViewHolder vh = findViewHolderForPosition(mPrevFastScrollFocusedPosition); 251 if (vh != null && 252 vh.itemView instanceof BaseRecyclerViewFastScrollBar.FastScrollFocusableView && 253 mLastFastScrollFocusedView != vh.itemView) { 254 mLastFastScrollFocusedView = 255 (BaseRecyclerViewFastScrollBar.FastScrollFocusableView) vh.itemView; 256 mLastFastScrollFocusedView.setFastScrollFocused(true, true); 257 } 258 } 259 } 260 }; 261 262 /** 263 * Smoothly snaps to a given position. We do this manually by calculating the keyframes 264 * ourselves and animating the scroll on the recycler view. 265 */ 266 private void smoothSnapToPosition(final int position, ScrollPositionState scrollPosState) { 267 removeCallbacks(mSmoothSnapNextFrameRunnable); 268 269 // Calculate the full animation from the current scroll position to the final scroll 270 // position, and then run the animation for the duration. 271 int curScrollY = getPaddingTop() + 272 (scrollPosState.rowIndex * scrollPosState.rowHeight) - scrollPosState.rowTopOffset; 273 int newScrollY = getScrollAtPosition(position, scrollPosState.rowHeight); 274 int numFrames = mFastScrollFrames.length; 275 for (int i = 0; i < numFrames; i++) { 276 // TODO(winsonc): We can interpolate this as well. 277 mFastScrollFrames[i] = (newScrollY - curScrollY) / numFrames; 278 } 279 mFastScrollFrameIndex = 0; 280 postOnAnimation(mSmoothSnapNextFrameRunnable); 281 } 282 283 /** 284 * Returns the current scroll state of the apps rows. 285 */ 286 private void getCurScrollState(ScrollPositionState stateOut, 287 List<AlphabeticalAppsList.AdapterItem> items) { 288 stateOut.rowIndex = -1; 289 stateOut.rowTopOffset = -1; 290 stateOut.rowHeight = -1; 291 292 // Return early if there are no items or we haven't been measured 293 if (items.isEmpty() || mNumAppsPerRow == 0) { 294 return; 295 } 296 297 int childCount = getChildCount(); 298 for (int i = 0; i < childCount; i++) { 299 View child = getChildAt(i); 300 int position = getChildPosition(child); 301 if (position != NO_POSITION) { 302 AlphabeticalAppsList.AdapterItem item = items.get(position); 303 if (item.viewType == AllAppsGridAdapter.ICON_VIEW_TYPE || 304 item.viewType == AllAppsGridAdapter.PREDICTION_ICON_VIEW_TYPE) { 305 stateOut.rowIndex = item.rowIndex; 306 stateOut.rowTopOffset = getLayoutManager().getDecoratedTop(child); 307 stateOut.rowHeight = child.getHeight(); 308 break; 309 } 310 } 311 } 312 } 313 314 /** 315 * Returns the scrollY for the given position in the adapter. 316 */ 317 private int getScrollAtPosition(int position, int rowHeight) { 318 AlphabeticalAppsList.AdapterItem item = mApps.getAdapterItems().get(position); 319 if (item.viewType == AllAppsGridAdapter.ICON_VIEW_TYPE || 320 item.viewType == AllAppsGridAdapter.PREDICTION_ICON_VIEW_TYPE) { 321 int offset = item.rowIndex > 0 ? getPaddingTop() : 0; 322 return offset + item.rowIndex * rowHeight; 323 } else { 324 return 0; 325 } 326 } 327 } 328
