Text selection changes - smart handles & drag accelerator

Drag accelerator:
After entering text selection mode, immediately dragging your finger
along the screen will select text. Once you have dragged past the initial
word the selection an offset is added so that the end of the selection is
not below your finger.

Smart handles:
When expanding the selection the handles snap to words, when shrinking the
selection the handles go by character, once you're in by-character mode
you can expand by character until you hit a word boundary where you will
then expand by word again. Your finger must past the first ~2 characters
in a word before the handle will jump to the word boundary.

Bug: 19356160
Bug: 19355947
Change-Id: I79b8ec5ae3159148cd2f15d2e63dd5045c2069e4

12 files changed, 370 insertions, 34 deletions

diff --git a/core/java/android/widget/Editor.java b/core/java/android/widget/Editor.java
index 1ba11da1f6f8..4f2f52a19932 100644
--- a/core/java/android/widget/Editor.java
+++ b/core/java/android/widget/Editor.java
@@ -218,6 +218,12 @@ public class Editor {
     WordIterator mWordIterator;
     SpellChecker mSpellChecker;
 
+    // This word iterator is set with text and used to determine word boundaries
+    // when a user is selecting text.
+    private WordIterator mWordIteratorWithText;
+    // Indicate that the text in the word iterator needs to be updated.
+    private boolean mUpdateWordIteratorText;
+
     private Rect mTempRect;
 
     private TextView mTextView;
@@ -684,9 +690,52 @@ public class Editor {
         return mTextView.getTransformationMethod() instanceof PasswordTransformationMethod;
     }
 
+    private int getWordStart(int offset) {
+        // FIXME - For this and similar methods we're not doing anything to check if there's
+        // a LocaleSpan in the text, this may be something we should try handling or checking for.
+        int retOffset = getWordIteratorWithText().getBeginning(offset);
+        if (retOffset == BreakIterator.DONE) retOffset = offset;
+        return retOffset;
+    }
+
+    private int getWordEnd(int offset, boolean includePunctuation) {
+        int retOffset = getWordIteratorWithText().getEnd(offset);
+        if (retOffset == BreakIterator.DONE) {
+            retOffset = offset;
+        } else if (includePunctuation) {
+            retOffset = handlePunctuation(retOffset);
+        }
+        return retOffset;
+    }
+
+    private boolean isEndBoundary(int offset) {
+        int thisEnd = getWordEnd(offset, false);
+        return offset == thisEnd;
+    }
+
+    private boolean isStartBoundary(int offset) {
+        int thisStart = getWordStart(offset);
+        return thisStart == offset;
+    }
+
+    private int handlePunctuation(int offset) {
+        // FIXME - Check with UX how repeated ending punctuation should be handled.
+        // FIXME - Check with UX if / how we would handle non sentence ending characters.
+        // FIXME - Consider punctuation in different languages.
+        CharSequence text = mTextView.getText();
+        if (offset < text.length()) {
+            int c = Character.codePointAt(text, offset);
+            if (c == 0x002e /* period */|| c == 0x003f /* question mark */
+                    || c == 0x0021 /* exclamation mark */) {
+                offset = Character.offsetByCodePoints(text, offset, 1);
+            }
+        }
+        return offset;
+    }
+
     /**
-     * Adjusts selection to the word under last touch offset.
-     * Return true if the operation was successfully performed.
+     * Adjusts selection to the word under last touch offset. Return true if the operation was
+     * successfully performed.
      */
     private boolean selectCurrentWord() {
         if (!canSelectText()) {
@@ -733,6 +782,8 @@ public class Editor {
             selectionStart = ((Spanned) mTextView.getText()).getSpanStart(urlSpan);
             selectionEnd = ((Spanned) mTextView.getText()).getSpanEnd(urlSpan);
         } else {
+            // FIXME - We should check if there's a LocaleSpan in the text, this may be
+            // something we should try handling or checking for.
             final WordIterator wordIterator = getWordIterator();
             wordIterator.setCharSequence(mTextView.getText(), minOffset, maxOffset);
 
@@ -755,6 +806,7 @@ public class Editor {
     void onLocaleChanged() {
         // Will be re-created on demand in getWordIterator with the proper new locale
         mWordIterator = null;
+        mWordIteratorWithText = null;
     }
 
     /**
@@ -767,6 +819,23 @@ public class Editor {
         return mWordIterator;
     }
 
+    private WordIterator getWordIteratorWithText() {
+        if (mWordIteratorWithText == null) {
+            mWordIteratorWithText = new WordIterator(mTextView.getTextServicesLocale());
+            mUpdateWordIteratorText = true;
+        }
+        if (mUpdateWordIteratorText) {
+            // FIXME - Shouldn't copy all of the text as only the area of the text relevant
+            // to the user's selection is needed. A possible solution would be to
+            // copy some number N of characters near the selection and then when the
+            // user approaches N then we'd do another copy of the next N characters.
+            CharSequence text = mTextView.getText();
+            mWordIteratorWithText.setCharSequence(text, 0, text.length());
+            mUpdateWordIteratorText = false;
+        }
+        return mWordIteratorWithText;
+    }
+
     private long getCharRange(int offset) {
         final int textLength = mTextView.getText().length();
         if (offset + 1 < textLength) {
@@ -915,9 +984,8 @@ public class Editor {
                 mTextView.startDrag(data, getTextThumbnailBuilder(selectedText), localState, 0);
                 stopSelectionActionMode();
             } else {
-                getSelectionController().hide();
-                selectCurrentWord();
-                getSelectionController().show();
+                stopSelectionActionMode();
+                startSelectionActionMode();
             }
             handled = true;
         }
@@ -1053,6 +1121,9 @@ public class Editor {
     void sendOnTextChanged(int start, int after) {
         updateSpellCheckSpans(start, start + after, false);
 
+        // Flip flag to indicate the word iterator needs to have the text reset.
+        mUpdateWordIteratorText = true;
+
         // Hide the controllers as soon as text is modified (typing, procedural...)
         // We do not hide the span controllers, since they can be added when a new text is
         // inserted into the text view (voice IME).
@@ -1608,6 +1679,9 @@ public class Editor {
             }
         }
 
+        if (selectionStarted) {
+            getSelectionController().enterDrag();
+        }
         return selectionStarted;
     }
 
@@ -2889,7 +2963,6 @@ public class Editor {
             }
 
             if (menu.hasVisibleItems() || mode.getCustomView() != null) {
-                getSelectionController().show();
                 mTextView.setHasTransientState(true);
                 return true;
             } else {
@@ -3227,6 +3300,8 @@ public class Editor {
         private Runnable mActionPopupShower;
         // Minimum touch target size for handles
         private int mMinSize;
+        // Indicates the line of text that the handle is on.
+        protected int mLine = -1;
 
         public HandleView(Drawable drawableLtr, Drawable drawableRtl) {
             super(mTextView.getContext());
@@ -3402,6 +3477,7 @@ public class Editor {
                     addPositionToTouchUpFilter(offset);
                 }
                 final int line = layout.getLineForOffset(offset);
+                mLine = line;
 
                 mPositionX = (int) (layout.getPrimaryHorizontal(offset) - 0.5f - mHotspotX -
                         getHorizontalOffset() + getCursorOffset());
@@ -3451,6 +3527,30 @@ public class Editor {
             }
         }
 
+        public void showAtLocation(int offset) {
+            // TODO - investigate if there's a better way to show the handles
+            // after the drag accelerator has occured.
+            int[] tmpCords = new int[2];
+            mTextView.getLocationInWindow(tmpCords);
+
+            Layout layout = mTextView.getLayout();
+            int posX = tmpCords[0];
+            int posY = tmpCords[1];
+
+            final int line = layout.getLineForOffset(offset);
+
+            int startX = (int) (layout.getPrimaryHorizontal(offset) - 0.5f
+                    - mHotspotX - getHorizontalOffset() + getCursorOffset());
+            int startY = layout.getLineBottom(line);
+
+            // Take TextView's padding and scroll into account.
+            startX += mTextView.viewportToContentHorizontalOffset();
+            startY += mTextView.viewportToContentVerticalOffset();
+
+            mContainer.showAtLocation(mTextView, Gravity.NO_GRAVITY,
+                    startX + posX, startY + posY);
+        }
+
         @Override
         protected void onDraw(Canvas c) {
             final int drawWidth = mDrawable.getIntrinsicWidth();
@@ -3689,6 +3789,12 @@ public class Editor {
     }
 
     private class SelectionStartHandleView extends HandleView {
+        // The previous offset this handle was at.
+        private int mPrevOffset;
+        // Indicates whether the cursor is making adjustments within a word.
+        private boolean mInWord = false;
+        // Offset to track difference between touch and word boundary.
+        protected int mTouchWordOffset;
 
         public SelectionStartHandleView(Drawable drawableLtr, Drawable drawableRtl) {
             super(drawableLtr, drawableRtl);
@@ -3696,11 +3802,7 @@ public class Editor {
 
         @Override
         protected int getHotspotX(Drawable drawable, boolean isRtlRun) {
-            if (isRtlRun) {
-                return drawable.getIntrinsicWidth() / 4;
-            } else {
-                return (drawable.getIntrinsicWidth() * 3) / 4;
-            }
+            return isRtlRun ? 0 : drawable.getIntrinsicWidth();
         }
 
         @Override
@@ -3722,21 +3824,81 @@ public class Editor {
 
         @Override
         public void updatePosition(float x, float y) {
-            int offset = mTextView.getOffsetForPosition(x, y);
-
-            // Handles can not cross and selection is at least one character
-            final int selectionEnd = mTextView.getSelectionEnd();
-            if (offset >= selectionEnd) offset = Math.max(0, selectionEnd - 1);
+            final int trueOffset = mTextView.getOffsetForPosition(x, y);
+            final int currLine = mTextView.getLineAtCoordinate(y);
+            int offset = trueOffset;
+            boolean positionCursor = false;
+
+            int end = getWordEnd(offset, true);
+            int start = getWordStart(offset);
+
+            if (offset < mPrevOffset) {
+                // User is increasing the selection.
+                if (!mInWord || currLine < mLine) {
+                    // We're not in a word, or we're on a different line so we'll expand by
+                    // word. First ensure the user has at least entered the next word.
+                    int offsetToWord = Math.min((end - start) / 2, 2);
+                    if (offset <= end - offsetToWord || currLine < mLine) {
+                        offset = start;
+                    } else {
+                        offset = mPrevOffset;
+                    }
+                }
+                mPrevOffset = offset;
+                mTouchWordOffset = trueOffset - offset;
+                mInWord = !isStartBoundary(offset);
+                positionCursor = true;
+            } else if (offset - mTouchWordOffset > mPrevOffset) {
+                // User is shrinking the selection.
+                if (currLine > mLine) {
+                    // We're on a different line, so we'll snap to word boundaries.
+                    offset = end;
+                }
+                offset -= mTouchWordOffset;
+                mPrevOffset = offset;
+                mInWord = !isEndBoundary(offset);
+                positionCursor = true;
+            }
 
-            positionAtCursorOffset(offset, false);
+            // Handles can not cross and selection is at least one character.
+            if (positionCursor) {
+                final int selectionEnd = mTextView.getSelectionEnd();
+                if (offset >= selectionEnd) {
+                    // We can't cross the handles so let's just constrain the Y value.
+                    int alteredOffset = mTextView.getOffsetAtCoordinate(mLine, x);
+                    if (alteredOffset >= selectionEnd) {
+                        // Can't pass the other drag handle.
+                        offset = Math.max(0, selectionEnd - 1);
+                    } else {
+                        offset = alteredOffset;
+                    }
+                }
+                positionAtCursorOffset(offset, false);
+            }
         }
 
         public ActionPopupWindow getActionPopupWindow() {
             return mActionPopupWindow;
         }
+
+        @Override
+        public boolean onTouchEvent(MotionEvent event) {
+            boolean superResult = super.onTouchEvent(event);
+            if (event.getActionMasked() == MotionEvent.ACTION_UP) {
+                // Reset the touch word offset when the user has lifted their finger.
+                mTouchWordOffset = 0;
+            }
+            return superResult;
+        }
     }
 
     private class SelectionEndHandleView extends HandleView {
+        // The previous offset this handle was at.
+        private int mPrevOffset;
+        // Indicates whether the cursor is making adjustments within a word.
+        private boolean mInWord = false;
+        // Offset to track difference between touch and word boundary.
+        protected int mTouchWordOffset;
 
         public SelectionEndHandleView(Drawable drawableLtr, Drawable drawableRtl) {
             super(drawableLtr, drawableRtl);
@@ -3744,11 +3906,7 @@ public class Editor {
 
         @Override
         protected int getHotspotX(Drawable drawable, boolean isRtlRun) {
-            if (isRtlRun) {
-                return (drawable.getIntrinsicWidth() * 3) / 4;
-            } else {
-                return drawable.getIntrinsicWidth() / 4;
-            }
+            return isRtlRun ? drawable.getIntrinsicWidth() : 0;
         }
 
         @Override
@@ -3770,20 +3928,72 @@ public class Editor {
 
         @Override
         public void updatePosition(float x, float y) {
-            int offset = mTextView.getOffsetForPosition(x, y);
-
-            // Handles can not cross and selection is at least one character
-            final int selectionStart = mTextView.getSelectionStart();
-            if (offset <= selectionStart) {
-                offset = Math.min(selectionStart + 1, mTextView.getText().length());
+            final int trueOffset = mTextView.getOffsetForPosition(x, y);
+            final int currLine = mTextView.getLineAtCoordinate(y);
+            int offset = trueOffset;
+            boolean positionCursor = false;
+
+            int end = getWordEnd(offset, true);
+            int start = getWordStart(offset);
+
+            if (offset > mPrevOffset) {
+                // User is increasing the selection.
+                if (!mInWord || currLine > mLine) {
+                    // We're not in a word, or we're on a different line so we'll expand by
+                    // word. First ensure the user has at least entered the next word.
+                    int midPoint = Math.min((end - start) / 2, 2);
+                    if (offset >= start + midPoint || currLine > mLine) {
+                        offset = end;
+                    } else {
+                        offset = mPrevOffset;
+                    }
+                }
+                mPrevOffset = offset;
+                mTouchWordOffset = offset - trueOffset;
+                mInWord = !isEndBoundary(offset);
+                positionCursor = true;
+            } else if (offset + mTouchWordOffset < mPrevOffset) {
+                // User is shrinking the selection.
+                if (currLine > mLine) {
+                    // We're on a different line, so we'll snap to word boundaries.
+                    offset = getWordStart(offset);
+                }
+                offset += mTouchWordOffset;
+                mPrevOffset = offset;
+                positionCursor = true;
+                mInWord = !isStartBoundary(offset);
             }
 
-            positionAtCursorOffset(offset, false);
+            if (positionCursor) {
+                final int selectionStart = mTextView.getSelectionStart();
+                if (offset <= selectionStart) {
+                    // We can't cross the handles so let's just constrain the Y value.
+                    int alteredOffset = mTextView.getOffsetAtCoordinate(mLine, x);
+                    int length = mTextView.getText().length();
+                    if (alteredOffset <= selectionStart) {
+                        // Can't pass the other drag handle.
+                        offset = Math.min(selectionStart + 1, length);
+                    } else {
+                        offset = Math.min(alteredOffset, length);
+                    }
+                }
+                positionAtCursorOffset(offset, false);
+            }
         }
 
         public void setActionPopupWindow(ActionPopupWindow actionPopupWindow) {
             mActionPopupWindow = actionPopupWindow;
         }
+
+        @Override
+        public boolean onTouchEvent(MotionEvent event) {
+            boolean superResult = super.onTouchEvent(event);
+            if (event.getActionMasked() == MotionEvent.ACTION_UP) {
+                // Reset the touch word offset when the user has lifted their finger.
+                mTouchWordOffset = 0;
+            }
+            return superResult;
+        }
     }
 
     /**
@@ -3866,6 +4076,11 @@ public class Editor {
         private float mDownPositionX, mDownPositionY;
         private boolean mGestureStayedInTapRegion;
 
+        // Where the user first starts the drag motion.
+        private int mStartOffset = -1;
+        // Indicates whether the user is selecting text and using the drag accelerator.
+        private boolean mDragAcceleratorActive;
+
         SelectionModifierCursorController() {
             resetTouchOffsets();
         }
@@ -3915,6 +4130,22 @@ public class Editor {
             if (mEndHandle != null) mEndHandle.hide();
         }
 
+        public void enterDrag() {
+            // Just need to init the handles / hide insertion cursor.
+            show();
+            mDragAcceleratorActive = true;
+            // Start location of selection.
+            mStartOffset = mTextView.getOffsetForPosition(mLastDownPositionX,
+                    mLastDownPositionY);
+            // Don't show the handles until user has lifted finger.
+            hide();
+
+            // This stops scrolling parents from intercepting the touch event, allowing
+            // the user to continue dragging across the screen to select text; TextView will
+            // scroll as necessary.
+            mTextView.getParent().requestDisallowInterceptTouchEvent(true);
+        }
+
         public void onTouchEvent(MotionEvent event) {
             // This is done even when the View does not have focus, so that long presses can start
             // selection and tap can move cursor from this tap position.
@@ -3923,7 +4154,7 @@ public class Editor {
                     final float x = event.getX();
                     final float y = event.getY();
 
-                    // Remember finger down position, to be able to start selection from there
+                    // Remember finger down position, to be able to start selection from there.
                     mMinTouchOffset = mMaxTouchOffset = mTextView.getOffsetForPosition(x, y);
 
                     // Double tap detection
@@ -3962,23 +4193,112 @@ public class Editor {
                     break;
 
                 case MotionEvent.ACTION_MOVE:
+                    final ViewConfiguration viewConfiguration = ViewConfiguration.get(
+                            mTextView.getContext());
+
                     if (mGestureStayedInTapRegion) {
                         final float deltaX = event.getX() - mDownPositionX;
                         final float deltaY = event.getY() - mDownPositionY;
                         final float distanceSquared = deltaX * deltaX + deltaY * deltaY;
 
-                        final ViewConfiguration viewConfiguration = ViewConfiguration.get(
-                                mTextView.getContext());
                         int doubleTapTouchSlop = viewConfiguration.getScaledDoubleTapTouchSlop();
 
                         if (distanceSquared > doubleTapTouchSlop * doubleTapTouchSlop) {
                             mGestureStayedInTapRegion = false;
                         }
                     }
+
+                    if (mStartHandle != null && mStartHandle.isShowing()) {
+                        // Don't do the drag if the handles are showing already.
+                        break;
+                    }
+
+                    if (mStartOffset != -1) {
+                        final int rawOffset = mTextView.getOffsetForPosition(event.getX(),
+                                event.getY());
+                        int offset = rawOffset;
+
+                        // We don't start "dragging" until the user is past the initial word that
+                        // gets selected on long press.
+                        int firstWordStart = getWordStart(mStartOffset);
+                        int firstWordEnd = getWordEnd(mStartOffset, false);
+                        if (offset > firstWordEnd || offset < firstWordStart) {
+
+                            // Basically the goal in the below code is to have the highlight be
+                            // offset so that your finger isn't covering the end point.
+                            int fingerOffset = viewConfiguration.getScaledTouchSlop();
+                            float mx = event.getX();
+                            float my = event.getY();
+                            if (mx > fingerOffset) mx -= fingerOffset;
+                            if (my > fingerOffset) my -= fingerOffset;
+                            offset = mTextView.getOffsetForPosition(mx, my);
+
+                            // Perform the check for closeness at edge of view, if we're very close
+                            // don't adjust the offset to be in front of the finger - otherwise the
+                            // user can't select words at the edge.
+                            if (mTextView.getWidth() - fingerOffset > mx) {
+                                // We're going by word, so we need to make sure that the offset
+                                // that we get is within this, so we'll get the previous boundary.
+                                final WordIterator wordIterator = getWordIteratorWithText();
+
+                                final int precedingOffset = wordIterator.preceding(offset);
+                                if (mStartOffset < offset) {
+                                    // Expanding with bottom handle, in this case the selection end
+                                    // is before the finger.
+                                    offset = Math.max(precedingOffset - 1, 0);
+                                } else {
+                                    // Expand with the start handle, in this case the selection
+                                    // start is before the finger.
+                                    if (precedingOffset == WordIterator.DONE) {
+                                        offset = 0;
+                                    } else {
+                                        offset = wordIterator.preceding(precedingOffset);
+                                    }
+                                }
+                            }
+                            if (offset == WordIterator.DONE)
+                                offset = rawOffset;
+
+                            // Need to adjust start offset based on direction of movement.
+                            int newStart = mStartOffset < offset ? getWordStart(mStartOffset)
+                                    : getWordEnd(mStartOffset, true);
+                            Selection.setSelection((Spannable) mTextView.getText(), newStart,
+                                    offset);
+                        }
+                    }
                     break;
 
                 case MotionEvent.ACTION_UP:
                     mPreviousTapUpTime = SystemClock.uptimeMillis();
+                    if (mDragAcceleratorActive) {
+                        // No longer dragging to select text, let the parent intercept events.
+                        mTextView.getParent().requestDisallowInterceptTouchEvent(false);
+
+                        show();
+                        int startOffset = mTextView.getSelectionStart();
+                        int endOffset = mTextView.getSelectionEnd();
+
+                        // Since we don't let drag handles pass once they're visible, we need to
+                        // make sure the start / end locations are correct because the user *can*
+                        // switch directions during the initial drag.
+                        if (endOffset < startOffset) {
+                            int tmp = endOffset;
+                            endOffset = startOffset;
+                            startOffset = tmp;
+
+                            // Also update the selection with the right offsets in this case.
+                            Selection.setSelection((Spannable) mTextView.getText(),
+                                    startOffset, endOffset);
+                        }
+
+                        // Need to do this to display the handles.
+                        mStartHandle.showAtLocation(startOffset);
+                        mEndHandle.showAtLocation(endOffset);
+
+                        // No longer the first dragging motion, reset.
+                        mDragAcceleratorActive = false;
+                        mStartOffset = -1;
+                    }
                     break;
             }
         }
@@ -4005,6 +4325,8 @@ public class Editor {
 
         public void resetTouchOffsets() {
             mMinTouchOffset = mMaxTouchOffset = -1;
+            mStartOffset = -1;
+            mDragAcceleratorActive = false;
         }
 
         /**
@@ -4014,6 +4336,13 @@ public class Editor {
             return mStartHandle != null && mStartHandle.isDragging();
         }
 
+        /**
+         * @return true if the user is selecting text using the drag accelerator.
+         */
+        public boolean isDragAcceleratorActive() {
+            return mDragAcceleratorActive;
+        }
+
         public void onTouchModeChanged(boolean isInTouchMode) {
             if (!isInTouchMode) {
                 hide();
diff --git a/core/java/android/widget/TextView.java b/core/java/android/widget/TextView.java
index 2d0a9cbb9d6d..d94ee89d3590 100644
--- a/core/java/android/widget/TextView.java
+++ b/core/java/android/widget/TextView.java
@@ -8093,7 +8093,14 @@ public class TextView extends View implements ViewTreeObserver.OnPreDrawListener
     public boolean onTouchEvent(MotionEvent event) {
         final int action = event.getActionMasked();
 
-        if (mEditor != null) mEditor.onTouchEvent(event);
+        if (mEditor != null) {
+            mEditor.onTouchEvent(event);
+
+            if (mEditor.mSelectionModifierCursorController != null &&
+                    mEditor.mSelectionModifierCursorController.isDragAcceleratorActive()) {
+                return true;
+            }
+        }
 
         final boolean superResult = super.onTouchEvent(event);
 
@@ -9099,7 +9106,7 @@ public class TextView extends View implements ViewTreeObserver.OnPreDrawListener
         return getLayout().getLineForVertical((int) y);
     }
 
-    private int getOffsetAtCoordinate(int line, float x) {
+    int getOffsetAtCoordinate(int line, float x) {
         x = convertToLocalHorizontalCoordinate(x);
         return getLayout().getOffsetForHorizontal(line, x);
     }
diff --git a/core/res/res/drawable-hdpi/text_select_handle_left_mtrl_alpha.png b/core/res/res/drawable-hdpi/text_select_handle_left_mtrl_alpha.png
index 9cdc25b4581d..1550b442d6df 100644
--- a/core/res/res/drawable-hdpi/text_select_handle_left_mtrl_alpha.png
+++ b/core/res/res/drawable-hdpi/text_select_handle_left_mtrl_alpha.png
diff --git a/core/res/res/drawable-hdpi/text_select_handle_right_mtrl_alpha.png b/core/res/res/drawable-hdpi/text_select_handle_right_mtrl_alpha.png
index 276d48091592..b309dfdc02c4 100644
--- a/core/res/res/drawable-hdpi/text_select_handle_right_mtrl_alpha.png
+++ b/core/res/res/drawable-hdpi/text_select_handle_right_mtrl_alpha.png
diff --git a/core/res/res/drawable-mdpi/text_select_handle_left_mtrl_alpha.png b/core/res/res/drawable-mdpi/text_select_handle_left_mtrl_alpha.png
index 95c0168cdc36..b36a41373aef 100644
--- a/core/res/res/drawable-mdpi/text_select_handle_left_mtrl_alpha.png
+++ b/core/res/res/drawable-mdpi/text_select_handle_left_mtrl_alpha.png
diff --git a/core/res/res/drawable-mdpi/text_select_handle_right_mtrl_alpha.png b/core/res/res/drawable-mdpi/text_select_handle_right_mtrl_alpha.png
index 569332abfeaa..afd0bd226b72 100644
--- a/core/res/res/drawable-mdpi/text_select_handle_right_mtrl_alpha.png
+++ b/core/res/res/drawable-mdpi/text_select_handle_right_mtrl_alpha.png
diff --git a/core/res/res/drawable-xhdpi/text_select_handle_left_mtrl_alpha.png b/core/res/res/drawable-xhdpi/text_select_handle_left_mtrl_alpha.png
index a01ac1030a5c..58f8c439a673 100644
--- a/core/res/res/drawable-xhdpi/text_select_handle_left_mtrl_alpha.png
+++ b/core/res/res/drawable-xhdpi/text_select_handle_left_mtrl_alpha.png
diff --git a/core/res/res/drawable-xhdpi/text_select_handle_right_mtrl_alpha.png b/core/res/res/drawable-xhdpi/text_select_handle_right_mtrl_alpha.png
index d3602d9888ec..42a893da515b 100644
--- a/core/res/res/drawable-xhdpi/text_select_handle_right_mtrl_alpha.png
+++ b/core/res/res/drawable-xhdpi/text_select_handle_right_mtrl_alpha.png
diff --git a/core/res/res/drawable-xxhdpi/text_select_handle_left_mtrl_alpha.png b/core/res/res/drawable-xxhdpi/text_select_handle_left_mtrl_alpha.png
index 75085ce6d48b..d0f274a03fde 100644
--- a/core/res/res/drawable-xxhdpi/text_select_handle_left_mtrl_alpha.png
+++ b/core/res/res/drawable-xxhdpi/text_select_handle_left_mtrl_alpha.png
diff --git a/core/res/res/drawable-xxhdpi/text_select_handle_right_mtrl_alpha.png b/core/res/res/drawable-xxhdpi/text_select_handle_right_mtrl_alpha.png
index e2eb5bed2330..f1f637a9d06b 100644
--- a/core/res/res/drawable-xxhdpi/text_select_handle_right_mtrl_alpha.png
+++ b/core/res/res/drawable-xxhdpi/text_select_handle_right_mtrl_alpha.png
diff --git a/core/res/res/drawable-xxxhdpi/text_select_handle_left_mtrl_alpha.png b/core/res/res/drawable-xxxhdpi/text_select_handle_left_mtrl_alpha.png
new file mode 100644
index 000000000000..643168f15b78
--- /dev/null
+++ b/core/res/res/drawable-xxxhdpi/text_select_handle_left_mtrl_alpha.png
diff --git a/core/res/res/drawable-xxxhdpi/text_select_handle_right_mtrl_alpha.png b/core/res/res/drawable-xxxhdpi/text_select_handle_right_mtrl_alpha.png
new file mode 100644
index 000000000000..e8f3aad7a99e
--- /dev/null
+++ b/core/res/res/drawable-xxxhdpi/text_select_handle_right_mtrl_alpha.png