tree 0bc5b420b1fd3cb0e4a72aef068540e358ebf198
parent eef0b1640bbc8c26c824836271a71b929726e895
author Federico Baron <fbaron@google.com> 1671651586 -0800
committer Federico Baron <fbaron@google.com> 1671749488 +0000

Fix bug where dragging icons in folders causes error

The error was caused by delta being larger than the range, which leads to an UnsupportedOperationException: "Final position of the spring cannot be greater than the max value". With this change, delta will never be greater than range.

Fix: 261674632
Test: 1. Settings > Display > Display size and text >>> Set display size to the biggest
2. Make folder
3. Go to landscape mode
4. Open folder
5. Quickly drag icon in folder
6. Verify that Launcher doesn't stop and drag is successful

Change-Id: I6c81755750acf0de8693b98caad8e7dab3e9f58a
