diff --git a/src/com/android/dialer/DialtactsActivity.java b/src/com/android/dialer/DialtactsActivity.java
index 89e5b5a..960900c 100644
--- a/src/com/android/dialer/DialtactsActivity.java
+++ b/src/com/android/dialer/DialtactsActivity.java
@@ -190,6 +190,11 @@
                 public void onHomeInActionBarSelected() {
                     exitSearchUi();
                 }
+
+                @Override
+                public void onCallNumberDirectly(String phoneNumber) {
+
+                }
     };
 
     /**
diff --git a/src/com/android/dialer/list/PhoneFavoriteTileView.java b/src/com/android/dialer/list/PhoneFavoriteTileView.java
index 4efc4db..8903e4b 100644
--- a/src/com/android/dialer/list/PhoneFavoriteTileView.java
+++ b/src/com/android/dialer/list/PhoneFavoriteTileView.java
@@ -78,6 +78,14 @@
         if (entry != null) {
             // Grab the phone-number to call directly... see {@link onClick()}
             mPhoneNumberString = entry.phoneNumber;
+            // If this is a blank entry, don't show anything.
+            // TODO krelease:Just hide the view for now. For this to truly look like an empty row
+            // the entire ContactTileRow needs to be hidden.
+            if (entry == ContactEntry.BLANK_ENTRY) {
+                setVisibility(View.INVISIBLE);
+            } else {
+                setVisibility(View.VISIBLE);
+            }
         }
     }
 
diff --git a/src/com/android/dialer/list/PhoneFavoritesTileAdapter.java b/src/com/android/dialer/list/PhoneFavoritesTileAdapter.java
index 992cb1f..614a0d3 100644
--- a/src/com/android/dialer/list/PhoneFavoritesTileAdapter.java
+++ b/src/com/android/dialer/list/PhoneFavoritesTileAdapter.java
@@ -17,14 +17,15 @@
 
 import android.animation.ObjectAnimator;
 import android.content.ContentUris;
+import android.content.ContentValues;
 import android.content.Context;
 import android.content.res.Resources;
 import android.database.Cursor;
-import android.graphics.Color;
 import android.graphics.Rect;
 import android.net.Uri;
 import android.provider.ContactsContract.CommonDataKinds.Phone;
 import android.provider.ContactsContract.Contacts;
+import android.provider.ContactsContract.PinnedPositions;
 import android.util.Log;
 import android.view.View;
 import android.view.ViewGroup;
@@ -35,9 +36,17 @@
 import com.android.contacts.common.ContactTileLoaderFactory;
 import com.android.contacts.common.R;
 import com.android.contacts.common.list.ContactEntry;
+import com.android.contacts.common.list.ContactTileAdapter.DisplayType;
 import com.android.contacts.common.list.ContactTileView;
+import com.android.internal.annotations.VisibleForTesting;
+
+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.
@@ -94,13 +103,26 @@
     private int mPhoneNumberIndex;
     private int mPhoneNumberTypeIndex;
     private int mPhoneNumberLabelIndex;
+    protected int mPinnedIndex;
+    protected int mContactIdForFrequentIndex;
 
-    private boolean mIsQuickContactEnabled = false;
     private final int mPaddingInPixels;
 
     /** Indicates whether a drag is in process. */
     private boolean mInDragging = false;
 
+    private static final int PIN_LIMIT = 20;
+
+    final Comparator<ContactEntry> mContactEntryComparator = new Comparator<ContactEntry>() {
+        @Override
+        public int compare(ContactEntry lhs, ContactEntry rhs) {
+            return ComparisonChain.start()
+                    .compare(lhs.pinned, rhs.pinned)
+                    .compare(lhs.name, rhs.name)
+                    .result();
+        }
+    };
+
     public PhoneFavoritesTileAdapter(Context context, ContactTileView.Listener listener,
             int numCols) {
         this(context, listener, numCols, ROW_LIMIT_DEFAULT);
@@ -143,10 +165,6 @@
         mColumnCount = columnCount;
     }
 
-    public void enableQuickContact(boolean enableQuickContact) {
-        mIsQuickContactEnabled = enableQuickContact;
-    }
-
     /**
      * Indicates whether a drag is in process.
      *
@@ -177,6 +195,8 @@
         mPhoneNumberIndex = ContactTileLoaderFactory.PHONE_NUMBER;
         mPhoneNumberTypeIndex = ContactTileLoaderFactory.PHONE_NUMBER_TYPE;
         mPhoneNumberLabelIndex = ContactTileLoaderFactory.PHONE_NUMBER_LABEL;
+        mPinnedIndex = ContactTileLoaderFactory.PINNED;
+        mContactIdForFrequentIndex = ContactTileLoaderFactory.CONTACT_ID_FOR_FREQUENT;
     }
 
     /**
@@ -213,14 +233,28 @@
      */
     private void saveCursorToCache(Cursor cursor) {
         mContactEntries.clear();
+
         cursor.moveToPosition(-1);
         while (cursor.moveToNext()) {
             final long id = cursor.getLong(mIdIndex);
+
             final String photoUri = cursor.getString(mPhotoUriIndex);
             final String lookupKey = cursor.getString(mLookupIndex);
 
             final ContactEntry contact = new ContactEntry();
+
+            final int pinned = cursor.getInt(mPinnedIndex);
+            final int starred = cursor.getInt(mStarredIndex);
+
             final String name = cursor.getString(mNameIndex);
+
+            if (starred > 0) {
+                contact.id = id;
+            } else {
+                // The contact id for frequent contacts is stored in the .contact_id field rather
+                // than the _id field
+                contact.id = cursor.getLong(mContactIdForFrequentIndex);
+            }
             contact.name = (name != null) ? name : mResources.getString(R.string.missing_name);
             contact.status = cursor.getString(mStatusIndex);
             contact.photoUri = (photoUri != null ? Uri.parse(photoUri) : null);
@@ -233,8 +267,14 @@
             contact.phoneLabel = (String) Phone.getTypeLabel(mResources, phoneNumberType,
                     phoneNumberCustomLabel);
             contact.phoneNumber = cursor.getString(mPhoneNumberIndex);
+
+            contact.pinned = pinned;
             mContactEntries.add(contact);
         }
+
+        arrangeContactsByPinnedPosition(mContactEntries);
+
+        notifyDataSetChanged();
     }
 
     /**
@@ -367,7 +407,7 @@
     @Override
     public void notifyDataSetChanged() {
         if (DEBUG) {
-            Log.v(TAG, "nofigyDataSetChanged");
+            Log.v(TAG, "notifyDataSetChanged");
         }
         super.notifyDataSetChanged();
     }
@@ -381,20 +421,10 @@
      */
     private void configureAnimationToView(ContactTileRow contactTileRowView, int position,
             int itemViewType) {
-        if (mInDragging) {
-            // If the one item above the row is being dragged, animates all following items to
-            // move up. If the item is a favorite tile, animate it to appear from right.
-            if (position >= getRowIndex(mDraggedEntryIndex)) {
-                if (itemViewType == ViewTypes.FREQUENT) {
-                    mTranslateVerticalAnimation.setTarget(contactTileRowView);
-                    mTranslateVerticalAnimation.setFloatValues(contactTileRowView.getHeight(), 0);
-                    mTranslateVerticalAnimation.clone().start();
-                } else {
-                    contactTileRowView.animateTilesAppearLeft(mDraggedEntryIndex -
-                            position * mColumnCount);
-                }
-            }
-        } else if (mDropEntryIndex != -1) {
+        // No need to animate anything if we are just entering a drag, because the blank
+        // entry takes the place of the dragged entry anyway.
+        if (mInDragging) return;
+        if (mDropEntryIndex != -1) {
             // If one item is dropped in front the row, animate all following rows to shift down.
             // If the item is a favorite tile, animate it to appear from left.
             if (position >= getRowIndex(mDropEntryIndex)) {
@@ -497,8 +527,8 @@
     public void popContactEntry(int index) {
         if (index >= 0 && index < mContactEntries.size()) {
             mDraggedEntry = mContactEntries.get(index);
+            mContactEntries.set(index, ContactEntry.BLANK_ENTRY);
             mDraggedEntryIndex = index;
-            mContactEntries.remove(index);
             notifyDataSetChanged();
         }
     }
@@ -509,17 +539,30 @@
      * @param index Location where the contact will be dropped.
      */
     public void dropContactEntry(int index) {
+        boolean changed = false;
         if (mDraggedEntry != null) {
             if (index >= 0 && index <= mContactEntries.size()) {
-                mContactEntries.add(index, mDraggedEntry);
+                // 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.
                 mDropEntryIndex = index;
+                changed = true;
             } else if (mDraggedEntryIndex >= 0 && mDraggedEntryIndex <= mContactEntries.size()) {
                 /** If the index is invalid, falls back to the original position of the contact. */
-                mContactEntries.add(mDraggedEntryIndex, mDraggedEntry);
+                mContactEntries.set(mDraggedEntryIndex, mDraggedEntry);
                 mDropEntryIndex = mDraggedEntryIndex;
+                notifyDataSetChanged();
+            }
+
+            if (changed && mDropEntryIndex < PIN_LIMIT) {
+                final ContentValues cv = getReflowedPinnedPositions(mContactEntries, mDraggedEntry,
+                        mDraggedEntryIndex, mDropEntryIndex);
+                final Uri pinUri = PinnedPositions.UPDATE_URI.buildUpon().appendQueryParameter(
+                            PinnedPositions.STAR_WHEN_PINNING, "true").build();
+                // update the database here with the new pinned positions
+                mContext.getContentResolver().update(pinUri, cv, null, null);
             }
             mDraggedEntry = null;
-            notifyDataSetChanged();
         }
     }
 
@@ -542,14 +585,14 @@
     }
 
     /**
-     * Removes a contact entry from the cache.
+     * Removes a contact entry from the list.
      *
      * @return True is an item is removed. False is there is no item to be removed.
      */
     public boolean removeContactEntry() {
         if (mPotentialRemoveEntryIndex >= 0 && mPotentialRemoveEntryIndex < mContactEntries.size()) {
-            mContactEntries.remove(mPotentialRemoveEntryIndex);
-            notifyDataSetChanged();
+            final ContactEntry entry = mContactEntries.get(mPotentialRemoveEntryIndex);
+            unstarAndUnpinContact(entry.lookupKey);
             return true;
         }
         return false;
@@ -575,7 +618,6 @@
     /**
      * Acts as a row item composed of {@link ContactTileView}
      *
-     * TODO: FREQUENT doesn't really need it.  Just let {@link #getView} return
      */
     public class ContactTileRow extends FrameLayout {
         private int mItemViewType;
@@ -810,6 +852,124 @@
         }
     }
 
+    /**
+     * Used when a contact is swiped away. 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);
+        mContext.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.
+     *
+     * 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
+    /* package */ void arrangeContactsByPinnedPosition(ArrayList<ContactEntry> toArrange) {
+        final PriorityQueue<ContactEntry> pinnedQueue =
+                new PriorityQueue<ContactEntry>(PIN_LIMIT, mContactEntryComparator);
+
+        final List<ContactEntry> unpinnedContacts = new LinkedList<ContactEntry>();
+
+        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) {
+                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 = 0; i < maxToPin; 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 ContentValues object 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.
+     *
+     * 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
+    /* package */ ContentValues getReflowedPinnedPositions(ArrayList<ContactEntry> list,
+            ContactEntry entryToPin, int oldPos, int newPinPos) {
+
+        final ContentValues cv = new ContentValues();
+
+        // Add the dragged contact at the user-requested spot.
+        cv.put(String.valueOf(entryToPin.id), newPinPos);
+
+        final int listSize = list.size();
+        if (oldPos < newPinPos && list.get(listSize - 1).pinned == (listSize - 1)) {
+            // The only time we should get here is it we are completely full - i.e. starting
+            // from the newly pinned contact to the end of the list, every single contact
+            // thereafter is pinned, and a contact is being shifted to the right by the user.
+            // Instead of trying to make room to the right, we should thus try to shift contacts
+            // to the left instead, working backwards through the list, starting from the contact
+            // which just got bumped.
+            for (int i = newPinPos; i >= 0; i--) {
+                final ContactEntry entry = list.get(i);
+                // Once we find an unpinned spot(or a blank entry), we can stop pushing contacts
+                // to the left.
+                if (entry.pinned > PIN_LIMIT) break;
+                cv.put(String.valueOf(entry.id), entry.pinned - 1);
+            }
+        } else {
+            // Shift any pinned contacts to the right as necessary, until an unpinned
+            // spot is found
+            for (int i = newPinPos; i < PIN_LIMIT && i < list.size(); i++) {
+                final ContactEntry entry = list.get(i);
+                if (entry.pinned > PIN_LIMIT) break;
+                cv.put(String.valueOf(entry.id), entry.pinned + 1);
+            }
+        }
+        return cv;
+    }
+
     protected static class ViewTypes {
         public static final int COUNT = 2;
         public static final int FREQUENT = 0;
diff --git a/tests/src/com/android/dialer/list/PhoneFavoritesTileAdapterTest.java b/tests/src/com/android/dialer/list/PhoneFavoritesTileAdapterTest.java
new file mode 100644
index 0000000..40d171c
--- /dev/null
+++ b/tests/src/com/android/dialer/list/PhoneFavoritesTileAdapterTest.java
@@ -0,0 +1,46 @@
+package com.android.dialer.list;
+
+import android.test.AndroidTestCase;
+
+public class PhoneFavoritesTileAdapterTest extends AndroidTestCase {
+    private PhoneFavoritesTileAdapter mAdapter;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        mAdapter = new PhoneFavoritesTileAdapter(getContext(), null, 3, 1);
+    }
+
+    /**
+     * TODO Krelease: Add tests
+     *
+     * Test cases (various combinations of):
+     * No pinned contacts
+     * One pinned contact
+     * Multiple pinned contacts with differing pinned positions
+     * Multiple pinned contacts with conflicting pinned positions
+     * Pinned contacts with pinned positions at the start, middle, end, and outside the list
+     */
+    public void testArrangeContactsByPinnedPosition() {
+
+    }
+
+    /**
+     * TODO Krelease: Add tests
+     *
+     * This method assumes that contacts have already been reordered by
+     * arrangeContactsByPinnedPosition, so we can test it with a less expansive set of test data.
+     *
+     * Test cases:
+     * Pin a single contact at the start, middle and end of a completely unpinned list
+     * Pin a single contact at the start, middle and end of a list with various numbers of
+     * pinned contacts
+     * Pin a single contact at the start, middle and end of a list where all contacts are pinned
+     * such that contacts are forced to the left as necessary.
+     */
+    public void testGetReflowedPinnedPositions() {
+
+    }
+
+
+}