| /* |
| * Copyright (C) 2013 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.dialer.app.list; |
| |
| import android.content.ContentProviderOperation; |
| import android.content.ContentUris; |
| import android.content.ContentValues; |
| import android.content.Context; |
| import android.content.OperationApplicationException; |
| import android.content.res.Resources; |
| import android.database.Cursor; |
| import android.net.Uri; |
| import android.os.RemoteException; |
| import android.provider.ContactsContract; |
| import android.provider.ContactsContract.CommonDataKinds.Phone; |
| import android.provider.ContactsContract.Contacts; |
| import android.provider.ContactsContract.PinnedPositions; |
| import android.support.annotation.VisibleForTesting; |
| import android.text.TextUtils; |
| import android.util.LongSparseArray; |
| import android.view.View; |
| import android.view.ViewGroup; |
| import android.widget.BaseAdapter; |
| import com.android.contacts.common.ContactTileLoaderFactory; |
| import com.android.contacts.common.list.ContactEntry; |
| import com.android.contacts.common.list.ContactTileView; |
| import com.android.dialer.app.R; |
| import com.android.dialer.common.LogUtil; |
| import com.android.dialer.contactphoto.ContactPhotoManager; |
| import com.android.dialer.contacts.ContactsComponent; |
| import com.android.dialer.duo.Duo; |
| import com.android.dialer.duo.DuoComponent; |
| import com.android.dialer.logging.InteractionEvent; |
| import com.android.dialer.logging.Logger; |
| import com.android.dialer.shortcuts.ShortcutRefresher; |
| import com.android.dialer.strictmode.StrictModeUtils; |
| import com.google.common.collect.ComparisonChain; |
| import java.util.ArrayList; |
| import java.util.Comparator; |
| import java.util.LinkedList; |
| import java.util.List; |
| import java.util.PriorityQueue; |
| |
| /** Also allows for a configurable number of columns as well as a maximum row of tiled contacts. */ |
| public class PhoneFavoritesTileAdapter extends BaseAdapter implements OnDragDropListener { |
| |
| // Pinned positions start from 1, so there are a total of 20 maximum pinned contacts |
| private static final int PIN_LIMIT = 21; |
| private static final String TAG = PhoneFavoritesTileAdapter.class.getSimpleName(); |
| private static final boolean DEBUG = false; |
| /** |
| * The soft limit on how many contact tiles to show. NOTE This soft limit would not restrict the |
| * number of starred contacts to show, rather 1. If the count of starred contacts is less than |
| * this limit, show 20 tiles total. 2. If the count of starred contacts is more than or equal to |
| * this limit, show all starred tiles and no frequents. |
| */ |
| private static final int TILES_SOFT_LIMIT = 20; |
| /** Contact data stored in cache. This is used to populate the associated view. */ |
| private ArrayList<ContactEntry> contactEntries = null; |
| |
| private int numFrequents; |
| private int numStarred; |
| |
| private ContactTileView.Listener listener; |
| private OnDataSetChangedForAnimationListener dataSetChangedListener; |
| private Context context; |
| private Resources resources; |
| private final Comparator<ContactEntry> contactEntryComparator = |
| new Comparator<ContactEntry>() { |
| @Override |
| public int compare(ContactEntry lhs, ContactEntry rhs) { |
| |
| return ComparisonChain.start() |
| .compare(lhs.pinned, rhs.pinned) |
| .compare(getPreferredSortName(lhs), getPreferredSortName(rhs)) |
| .result(); |
| } |
| |
| private String getPreferredSortName(ContactEntry contactEntry) { |
| return ContactsComponent.get(context) |
| .contactDisplayPreferences() |
| .getSortName(contactEntry.namePrimary, contactEntry.nameAlternative); |
| } |
| }; |
| /** Back up of the temporarily removed Contact during dragging. */ |
| private ContactEntry draggedEntry = null; |
| /** Position of the temporarily removed contact in the cache. */ |
| private int draggedEntryIndex = -1; |
| /** New position of the temporarily removed contact in the cache. */ |
| private int dropEntryIndex = -1; |
| /** New position of the temporarily entered contact in the cache. */ |
| private int dragEnteredEntryIndex = -1; |
| |
| private boolean awaitingRemove = false; |
| private boolean delayCursorUpdates = false; |
| private ContactPhotoManager photoManager; |
| |
| /** Indicates whether a drag is in process. */ |
| private boolean inDragging = false; |
| |
| public PhoneFavoritesTileAdapter( |
| Context context, |
| ContactTileView.Listener listener, |
| OnDataSetChangedForAnimationListener dataSetChangedListener) { |
| this.dataSetChangedListener = dataSetChangedListener; |
| this.listener = listener; |
| this.context = context; |
| resources = context.getResources(); |
| numFrequents = 0; |
| contactEntries = new ArrayList<>(); |
| } |
| |
| void setPhotoLoader(ContactPhotoManager photoLoader) { |
| photoManager = photoLoader; |
| } |
| |
| /** |
| * Indicates whether a drag is in process. |
| * |
| * @param inDragging Boolean variable indicating whether there is a drag in process. |
| */ |
| private void setInDragging(boolean inDragging) { |
| delayCursorUpdates = inDragging; |
| this.inDragging = inDragging; |
| } |
| |
| /** |
| * Gets the number of frequents from the passed in cursor. |
| * |
| * <p>This methods is needed so the GroupMemberTileAdapter can override this. |
| * |
| * @param cursor The cursor to get number of frequents from. |
| */ |
| private void saveNumFrequentsFromCursor(Cursor cursor) { |
| numFrequents = cursor.getCount() - numStarred; |
| } |
| |
| /** |
| * Creates {@link ContactTileView}s for each item in {@link Cursor}. |
| * |
| * <p>Else use {@link ContactTileLoaderFactory} |
| */ |
| void setContactCursor(Cursor cursor) { |
| if (!delayCursorUpdates && cursor != null && !cursor.isClosed()) { |
| numStarred = getNumStarredContacts(cursor); |
| if (awaitingRemove) { |
| dataSetChangedListener.cacheOffsetsForDatasetChange(); |
| } |
| |
| saveNumFrequentsFromCursor(cursor); |
| saveCursorToCache(cursor); |
| // cause a refresh of any views that rely on this data |
| notifyDataSetChanged(); |
| // about to start redraw |
| dataSetChangedListener.onDataSetChangedForAnimation(); |
| } |
| } |
| |
| /** |
| * Saves the cursor data to the cache, to speed up UI changes. |
| * |
| * @param cursor Returned cursor from {@link ContactTileLoaderFactory} with data to populate the |
| * view. |
| */ |
| private void saveCursorToCache(Cursor cursor) { |
| contactEntries.clear(); |
| |
| if (cursor == null) { |
| return; |
| } |
| |
| final LongSparseArray<Object> duplicates = new LongSparseArray<>(cursor.getCount()); |
| |
| // Track the length of {@link #mContactEntries} and compare to {@link #TILES_SOFT_LIMIT}. |
| int counter = 0; |
| |
| // Data for logging |
| int starredContactsCount = 0; |
| int pinnedContactsCount = 0; |
| int multipleNumbersContactsCount = 0; |
| int contactsWithPhotoCount = 0; |
| int contactsWithNameCount = 0; |
| int lightbringerReachableContactsCount = 0; |
| |
| // The cursor should not be closed since this is invoked from a CursorLoader. |
| if (cursor.moveToFirst()) { |
| int starredColumn = cursor.getColumnIndexOrThrow(Contacts.STARRED); |
| int contactIdColumn = cursor.getColumnIndexOrThrow(Phone.CONTACT_ID); |
| int photoUriColumn = cursor.getColumnIndexOrThrow(Contacts.PHOTO_URI); |
| int lookupKeyColumn = cursor.getColumnIndexOrThrow(Contacts.LOOKUP_KEY); |
| int pinnedColumn = cursor.getColumnIndexOrThrow(Contacts.PINNED); |
| int nameColumn = cursor.getColumnIndexOrThrow(Contacts.DISPLAY_NAME_PRIMARY); |
| int nameAlternativeColumn = cursor.getColumnIndexOrThrow(Contacts.DISPLAY_NAME_ALTERNATIVE); |
| int isDefaultNumberColumn = cursor.getColumnIndexOrThrow(Phone.IS_SUPER_PRIMARY); |
| int phoneTypeColumn = cursor.getColumnIndexOrThrow(Phone.TYPE); |
| int phoneLabelColumn = cursor.getColumnIndexOrThrow(Phone.LABEL); |
| int phoneNumberColumn = cursor.getColumnIndexOrThrow(Phone.NUMBER); |
| do { |
| final int starred = cursor.getInt(starredColumn); |
| final long id; |
| |
| // We display a maximum of TILES_SOFT_LIMIT contacts, or the total number of starred |
| // whichever is greater. |
| if (starred < 1 && counter >= TILES_SOFT_LIMIT) { |
| break; |
| } else { |
| id = cursor.getLong(contactIdColumn); |
| } |
| |
| final ContactEntry existing = (ContactEntry) duplicates.get(id); |
| if (existing != null) { |
| // Check if the existing number is a default number. If not, clear the phone number |
| // and label fields so that the disambiguation dialog will show up. |
| if (!existing.isDefaultNumber) { |
| existing.phoneLabel = null; |
| existing.phoneNumber = null; |
| } |
| continue; |
| } |
| |
| final String photoUri = cursor.getString(photoUriColumn); |
| final String lookupKey = cursor.getString(lookupKeyColumn); |
| final int pinned = cursor.getInt(pinnedColumn); |
| final String name = cursor.getString(nameColumn); |
| final String nameAlternative = cursor.getString(nameAlternativeColumn); |
| final boolean isStarred = cursor.getInt(starredColumn) > 0; |
| final boolean isDefaultNumber = cursor.getInt(isDefaultNumberColumn) > 0; |
| |
| final ContactEntry contact = new ContactEntry(); |
| |
| contact.id = id; |
| contact.namePrimary = |
| (!TextUtils.isEmpty(name)) ? name : resources.getString(R.string.missing_name); |
| contact.nameAlternative = |
| (!TextUtils.isEmpty(nameAlternative)) |
| ? nameAlternative |
| : resources.getString(R.string.missing_name); |
| contact.photoUri = (photoUri != null ? Uri.parse(photoUri) : null); |
| contact.lookupKey = lookupKey; |
| contact.lookupUri = |
| ContentUris.withAppendedId( |
| Uri.withAppendedPath(Contacts.CONTENT_LOOKUP_URI, lookupKey), id); |
| contact.isFavorite = isStarred; |
| contact.isDefaultNumber = isDefaultNumber; |
| |
| // Set phone number and label |
| final int phoneNumberType = cursor.getInt(phoneTypeColumn); |
| final String phoneNumberCustomLabel = cursor.getString(phoneLabelColumn); |
| contact.phoneLabel = |
| (String) Phone.getTypeLabel(resources, phoneNumberType, phoneNumberCustomLabel); |
| contact.phoneNumber = cursor.getString(phoneNumberColumn); |
| |
| contact.pinned = pinned; |
| contactEntries.add(contact); |
| |
| // Set counts for logging |
| if (isStarred) { |
| // mNumStarred might be larger than the number of visible starred contact, |
| // since it includes invisible ones (starred contact with no phone number). |
| starredContactsCount++; |
| } |
| if (pinned != PinnedPositions.UNPINNED) { |
| pinnedContactsCount++; |
| } |
| if (!TextUtils.isEmpty(name)) { |
| contactsWithNameCount++; |
| } |
| if (photoUri != null) { |
| contactsWithPhotoCount++; |
| } |
| |
| duplicates.put(id, contact); |
| |
| counter++; |
| } while (cursor.moveToNext()); |
| } |
| |
| awaitingRemove = false; |
| |
| arrangeContactsByPinnedPosition(contactEntries); |
| |
| ShortcutRefresher.refresh(context, contactEntries); |
| notifyDataSetChanged(); |
| |
| Duo duo = DuoComponent.get(context).getDuo(); |
| for (ContactEntry contact : contactEntries) { |
| if (contact.phoneNumber == null) { |
| multipleNumbersContactsCount++; |
| } else if (duo.isReachable(context, contact.phoneNumber)) { |
| lightbringerReachableContactsCount++; |
| } |
| } |
| |
| Logger.get(context) |
| .logSpeedDialContactComposition( |
| counter, |
| starredContactsCount, |
| pinnedContactsCount, |
| multipleNumbersContactsCount, |
| contactsWithPhotoCount, |
| contactsWithNameCount, |
| lightbringerReachableContactsCount); |
| // Logs for manual testing |
| LogUtil.v("PhoneFavoritesTileAdapter.saveCursorToCache", "counter: %d", counter); |
| LogUtil.v( |
| "PhoneFavoritesTileAdapter.saveCursorToCache", |
| "starredContactsCount: %d", |
| starredContactsCount); |
| LogUtil.v( |
| "PhoneFavoritesTileAdapter.saveCursorToCache", |
| "pinnedContactsCount: %d", |
| pinnedContactsCount); |
| LogUtil.v( |
| "PhoneFavoritesTileAdapter.saveCursorToCache", |
| "multipleNumbersContactsCount: %d", |
| multipleNumbersContactsCount); |
| LogUtil.v( |
| "PhoneFavoritesTileAdapter.saveCursorToCache", |
| "contactsWithPhotoCount: %d", |
| contactsWithPhotoCount); |
| LogUtil.v( |
| "PhoneFavoritesTileAdapter.saveCursorToCache", |
| "contactsWithNameCount: %d", |
| contactsWithNameCount); |
| } |
| |
| /** Iterates over the {@link Cursor} Returns position of the first NON Starred Contact */ |
| private int getNumStarredContacts(Cursor cursor) { |
| if (cursor == null) { |
| return 0; |
| } |
| |
| if (cursor.moveToFirst()) { |
| int starredColumn = cursor.getColumnIndex(Contacts.STARRED); |
| do { |
| if (cursor.getInt(starredColumn) == 0) { |
| return cursor.getPosition(); |
| } |
| } while (cursor.moveToNext()); |
| } |
| // There are not NON Starred contacts in cursor |
| // Set divider position to end |
| return cursor.getCount(); |
| } |
| |
| /** Returns the number of frequents that will be displayed in the list. */ |
| int getNumFrequents() { |
| return numFrequents; |
| } |
| |
| @Override |
| public int getCount() { |
| if (contactEntries == null) { |
| return 0; |
| } |
| |
| return contactEntries.size(); |
| } |
| |
| /** |
| * Returns an ArrayList of the {@link ContactEntry}s that are to appear on the row for the given |
| * position. |
| */ |
| @Override |
| public ContactEntry getItem(int position) { |
| return contactEntries.get(position); |
| } |
| |
| /** |
| * For the top row of tiled contacts, the item id is the position of the row of contacts. For |
| * frequent contacts, the item id is the maximum number of rows of tiled contacts + the actual |
| * contact id. Since contact ids are always greater than 0, this guarantees that all items within |
| * this adapter will always have unique ids. |
| */ |
| @Override |
| public long getItemId(int position) { |
| return getItem(position).id; |
| } |
| |
| @Override |
| public boolean hasStableIds() { |
| return true; |
| } |
| |
| @Override |
| public boolean areAllItemsEnabled() { |
| return true; |
| } |
| |
| @Override |
| public boolean isEnabled(int position) { |
| return getCount() > 0; |
| } |
| |
| @Override |
| public void notifyDataSetChanged() { |
| if (DEBUG) { |
| LogUtil.v(TAG, "notifyDataSetChanged"); |
| } |
| super.notifyDataSetChanged(); |
| } |
| |
| @Override |
| public View getView(int position, View convertView, ViewGroup parent) { |
| if (DEBUG) { |
| LogUtil.v(TAG, "get view for " + position); |
| } |
| |
| PhoneFavoriteTileView tileView = null; |
| |
| if (convertView instanceof PhoneFavoriteTileView) { |
| tileView = (PhoneFavoriteTileView) convertView; |
| } |
| |
| if (tileView == null) { |
| tileView = |
| (PhoneFavoriteTileView) View.inflate(context, R.layout.phone_favorite_tile_view, null); |
| } |
| tileView.setPhotoManager(photoManager); |
| tileView.setListener(listener); |
| tileView.loadFromContact(getItem(position)); |
| tileView.setPosition(position); |
| return tileView; |
| } |
| |
| @Override |
| public int getViewTypeCount() { |
| return ViewTypes.COUNT; |
| } |
| |
| @Override |
| public int getItemViewType(int position) { |
| return ViewTypes.TILE; |
| } |
| |
| /** |
| * Temporarily removes a contact from the list for UI refresh. Stores data for this contact in the |
| * back-up variable. |
| * |
| * @param index Position of the contact to be removed. |
| */ |
| private void popContactEntry(int index) { |
| if (isIndexInBound(index)) { |
| draggedEntry = contactEntries.get(index); |
| draggedEntryIndex = index; |
| dragEnteredEntryIndex = index; |
| markDropArea(dragEnteredEntryIndex); |
| } |
| } |
| |
| /** |
| * @param itemIndex Position of the contact in {@link #contactEntries}. |
| * @return True if the given index is valid for {@link #contactEntries}. |
| */ |
| boolean isIndexInBound(int itemIndex) { |
| return itemIndex >= 0 && itemIndex < contactEntries.size(); |
| } |
| |
| /** |
| * Mark the tile as drop area by given the item index in {@link #contactEntries}. |
| * |
| * @param itemIndex Position of the contact in {@link #contactEntries}. |
| */ |
| private void markDropArea(int itemIndex) { |
| if (draggedEntry != null |
| && isIndexInBound(dragEnteredEntryIndex) |
| && isIndexInBound(itemIndex)) { |
| dataSetChangedListener.cacheOffsetsForDatasetChange(); |
| // Remove the old placeholder item and place the new placeholder item. |
| contactEntries.remove(dragEnteredEntryIndex); |
| dragEnteredEntryIndex = itemIndex; |
| contactEntries.add(dragEnteredEntryIndex, ContactEntry.BLANK_ENTRY); |
| ContactEntry.BLANK_ENTRY.id = draggedEntry.id; |
| dataSetChangedListener.onDataSetChangedForAnimation(); |
| notifyDataSetChanged(); |
| } |
| } |
| |
| /** Drops the temporarily removed contact to the desired location in the list. */ |
| private void handleDrop() { |
| boolean changed = false; |
| if (draggedEntry != null) { |
| if (isIndexInBound(dragEnteredEntryIndex) && dragEnteredEntryIndex != draggedEntryIndex) { |
| // Don't add the ContactEntry here (to prevent a double animation from occuring). |
| // When we receive a new cursor the list of contact entries will automatically be |
| // populated with the dragged ContactEntry at the correct spot. |
| dropEntryIndex = dragEnteredEntryIndex; |
| contactEntries.set(dropEntryIndex, draggedEntry); |
| dataSetChangedListener.cacheOffsetsForDatasetChange(); |
| changed = true; |
| } else if (isIndexInBound(draggedEntryIndex)) { |
| // If {@link #mDragEnteredEntryIndex} is invalid, |
| // falls back to the original position of the contact. |
| contactEntries.remove(dragEnteredEntryIndex); |
| contactEntries.add(draggedEntryIndex, draggedEntry); |
| dropEntryIndex = draggedEntryIndex; |
| notifyDataSetChanged(); |
| } |
| |
| if (changed && dropEntryIndex < PIN_LIMIT) { |
| ArrayList<ContentProviderOperation> operations = |
| getReflowedPinningOperations(contactEntries, draggedEntryIndex, dropEntryIndex); |
| StrictModeUtils.bypass(() -> updateDatabaseWithPinnedPositions(operations)); |
| } |
| draggedEntry = null; |
| } |
| } |
| |
| private void updateDatabaseWithPinnedPositions(ArrayList<ContentProviderOperation> operations) { |
| if (operations.isEmpty()) { |
| // Nothing to update |
| return; |
| } |
| try { |
| context.getContentResolver().applyBatch(ContactsContract.AUTHORITY, operations); |
| Logger.get(context).logInteraction(InteractionEvent.Type.SPEED_DIAL_PIN_CONTACT); |
| } catch (RemoteException | OperationApplicationException e) { |
| LogUtil.e(TAG, "Exception thrown when pinning contacts", e); |
| } |
| } |
| |
| /** |
| * Used when a contact is removed from speeddial. This will both unstar and set pinned position of |
| * the contact to PinnedPosition.DEMOTED so that it doesn't show up anymore in the favorites list. |
| */ |
| private void unstarAndUnpinContact(Uri contactUri) { |
| final ContentValues values = new ContentValues(2); |
| values.put(Contacts.STARRED, false); |
| values.put(Contacts.PINNED, PinnedPositions.DEMOTED); |
| StrictModeUtils.bypass( |
| () -> context.getContentResolver().update(contactUri, values, null, null)); |
| } |
| |
| /** |
| * Given a list of contacts that each have pinned positions, rearrange the list (destructive) such |
| * that all pinned contacts are in their defined pinned positions, and unpinned contacts take the |
| * spaces between those pinned contacts. Demoted contacts should not appear in the resulting list. |
| * |
| * <p>This method also updates the pinned positions of pinned contacts so that they are all unique |
| * positive integers within range from 0 to toArrange.size() - 1. This is because when the contact |
| * entries are read from the database, it is possible for them to have overlapping pin positions |
| * due to sync or modifications by third party apps. |
| */ |
| @VisibleForTesting |
| private void arrangeContactsByPinnedPosition(ArrayList<ContactEntry> toArrange) { |
| final PriorityQueue<ContactEntry> pinnedQueue = |
| new PriorityQueue<>(PIN_LIMIT, contactEntryComparator); |
| |
| final List<ContactEntry> unpinnedContacts = new LinkedList<>(); |
| |
| final int length = toArrange.size(); |
| for (int i = 0; i < length; i++) { |
| final ContactEntry contact = toArrange.get(i); |
| // Decide whether the contact is hidden(demoted), pinned, or unpinned |
| if (contact.pinned > PIN_LIMIT || contact.pinned == PinnedPositions.UNPINNED) { |
| unpinnedContacts.add(contact); |
| } else if (contact.pinned > PinnedPositions.DEMOTED) { |
| // Demoted or contacts with negative pinned positions are ignored. |
| // Pinned contacts go into a priority queue where they are ranked by pinned |
| // position. This is required because the contacts provider does not return |
| // contacts ordered by pinned position. |
| pinnedQueue.add(contact); |
| } |
| } |
| |
| final int maxToPin = Math.min(PIN_LIMIT, pinnedQueue.size() + unpinnedContacts.size()); |
| |
| toArrange.clear(); |
| for (int i = 1; i < maxToPin + 1; i++) { |
| if (!pinnedQueue.isEmpty() && pinnedQueue.peek().pinned <= i) { |
| final ContactEntry toPin = pinnedQueue.poll(); |
| toPin.pinned = i; |
| toArrange.add(toPin); |
| } else if (!unpinnedContacts.isEmpty()) { |
| toArrange.add(unpinnedContacts.remove(0)); |
| } |
| } |
| |
| // If there are still contacts in pinnedContacts at this point, it means that the pinned |
| // positions of these pinned contacts exceed the actual number of contacts in the list. |
| // For example, the user had 10 frequents, starred and pinned one of them at the last spot, |
| // and then cleared frequents. Contacts in this situation should become unpinned. |
| while (!pinnedQueue.isEmpty()) { |
| final ContactEntry entry = pinnedQueue.poll(); |
| entry.pinned = PinnedPositions.UNPINNED; |
| toArrange.add(entry); |
| } |
| |
| // Any remaining unpinned contacts that weren't in the gaps between the pinned contacts |
| // now just get appended to the end of the list. |
| toArrange.addAll(unpinnedContacts); |
| } |
| |
| /** |
| * Given an existing list of contact entries and a single entry that is to be pinned at a |
| * particular position, return a list of {@link ContentProviderOperation}s that contains new |
| * pinned positions for all contacts that are forced to be pinned at new positions, trying as much |
| * as possible to keep pinned contacts at their original location. |
| * |
| * <p>At this point in time the pinned position of each contact in the list has already been |
| * updated by {@link #arrangeContactsByPinnedPosition}, so we can assume that all pinned |
| * positions(within {@link #PIN_LIMIT} are unique positive integers. |
| */ |
| @VisibleForTesting |
| private ArrayList<ContentProviderOperation> getReflowedPinningOperations( |
| ArrayList<ContactEntry> list, int oldPos, int newPinPos) { |
| final ArrayList<ContentProviderOperation> positions = new ArrayList<>(); |
| final int lowerBound = Math.min(oldPos, newPinPos); |
| final int upperBound = Math.max(oldPos, newPinPos); |
| for (int i = lowerBound; i <= upperBound; i++) { |
| final ContactEntry entry = list.get(i); |
| |
| // Pinned positions in the database start from 1 instead of being zero-indexed like |
| // arrays, so offset by 1. |
| final int databasePinnedPosition = i + 1; |
| if (entry.pinned == databasePinnedPosition) { |
| continue; |
| } |
| |
| final Uri uri = Uri.withAppendedPath(Contacts.CONTENT_URI, String.valueOf(entry.id)); |
| final ContentValues values = new ContentValues(); |
| values.put(Contacts.PINNED, databasePinnedPosition); |
| positions.add(ContentProviderOperation.newUpdate(uri).withValues(values).build()); |
| } |
| return positions; |
| } |
| |
| @Override |
| public void onDragStarted(int x, int y, PhoneFavoriteSquareTileView view) { |
| setInDragging(true); |
| final int itemIndex = contactEntries.indexOf(view.getContactEntry()); |
| popContactEntry(itemIndex); |
| } |
| |
| @Override |
| public void onDragHovered(int x, int y, PhoneFavoriteSquareTileView view) { |
| if (view == null) { |
| // The user is hovering over a view that is not a contact tile, no need to do |
| // anything here. |
| return; |
| } |
| final int itemIndex = contactEntries.indexOf(view.getContactEntry()); |
| if (inDragging |
| && dragEnteredEntryIndex != itemIndex |
| && isIndexInBound(itemIndex) |
| && itemIndex < PIN_LIMIT |
| && itemIndex >= 0) { |
| markDropArea(itemIndex); |
| } |
| } |
| |
| @Override |
| public void onDragFinished(int x, int y) { |
| setInDragging(false); |
| // A contact has been dragged to the RemoveView in order to be unstarred, so simply wait |
| // for the new contact cursor which will cause the UI to be refreshed without the unstarred |
| // contact. |
| if (!awaitingRemove) { |
| handleDrop(); |
| } |
| } |
| |
| @Override |
| public void onDroppedOnRemove() { |
| if (draggedEntry != null) { |
| unstarAndUnpinContact(draggedEntry.lookupUri); |
| awaitingRemove = true; |
| Logger.get(context).logInteraction(InteractionEvent.Type.SPEED_DIAL_REMOVE_CONTACT); |
| } |
| } |
| |
| interface OnDataSetChangedForAnimationListener { |
| |
| void onDataSetChangedForAnimation(long... idsInPlace); |
| |
| void cacheOffsetsForDatasetChange(); |
| } |
| |
| private static class ViewTypes { |
| |
| static final int TILE = 0; |
| static final int COUNT = 1; |
| } |
| } |
