diff --git a/src/com/android/documentsui/BaseActivity.java b/src/com/android/documentsui/BaseActivity.java
index e9b1743..d9da559 100644
--- a/src/com/android/documentsui/BaseActivity.java
+++ b/src/com/android/documentsui/BaseActivity.java
@@ -64,6 +64,7 @@
 import com.android.documentsui.services.FileOperationService;
 import com.android.documentsui.services.FileOperations;
 import com.android.documentsui.sorting.SortController;
+import com.android.documentsui.sorting.SortMenuController;
 import com.android.documentsui.sorting.SortModel;
 
 import java.io.FileNotFoundException;
@@ -127,6 +128,7 @@
     private long mStartTime;
 
     private SortController mSortController;
+    private SortMenuController mSortMenuController;
 
     public abstract void onDocumentPicked(DocumentInfo doc, Model model);
     public abstract void onDocumentsPicked(List<DocumentInfo> docs);
@@ -171,7 +173,7 @@
         getContentResolver().registerContentObserver(
                 RootsCache.sNotificationUri, false, mRootsCacheObserver);
 
-        mSearchManager = new SearchViewManager(this, icicle);
+        mSearchManager = new SearchViewManager(this, icicle, mState.sortModel);
 
         DocumentsToolbar toolbar = (DocumentsToolbar) findViewById(R.id.toolbar);
         setActionBar(toolbar);
@@ -182,7 +184,9 @@
 
         mNavigator = new NavigationViewManager(mDrawer, toolbar, mState, this, breadcrumb);
 
-        mSortController = new SortController(mState.sortModel);
+        mSortController = new SortController(mState.sortModel, this);
+        mSortMenuController = new SortMenuController(getResources());
+        mSortController.manage(mSortMenuController);
 
         // Base classes must update result in their onCreate.
         setResult(Activity.RESULT_CANCELED);
@@ -197,6 +201,8 @@
         boolean fullBarSearch = getResources().getBoolean(R.bool.full_bar_search_view);
         mSearchManager.install((DocumentsToolbar) findViewById(R.id.toolbar), fullBarSearch);
 
+        mSortMenuController.install(menu.findItem(R.id.menu_sort));
+
         return showMenu;
     }
 
@@ -307,18 +313,6 @@
                 // SearchViewManager listens for this directly.
                 return false;
 
-            case R.id.menu_sort_name:
-                setUserSortOrder(State.SORT_ORDER_DISPLAY_NAME);
-                return true;
-
-            case R.id.menu_sort_date:
-                setUserSortOrder(State.SORT_ORDER_LAST_MODIFIED);
-                return true;
-
-            case R.id.menu_sort_size:
-                setUserSortOrder(State.SORT_ORDER_SIZE);
-                return true;
-
             case R.id.menu_grid:
                 setViewMode(State.MODE_GRID);
                 return true;
@@ -530,29 +524,6 @@
     }
 
     /**
-     * Set state sort order based on explicit user action.
-     */
-    void setUserSortOrder(int sortOrder) {
-        switch(sortOrder) {
-            case State.SORT_ORDER_DISPLAY_NAME:
-                Metrics.logUserAction(this, Metrics.USER_ACTION_SORT_NAME);
-                break;
-            case State.SORT_ORDER_LAST_MODIFIED:
-                Metrics.logUserAction(this, Metrics.USER_ACTION_SORT_DATE);
-                break;
-            case State.SORT_ORDER_SIZE:
-                Metrics.logUserAction(this, Metrics.USER_ACTION_SORT_SIZE);
-                break;
-        }
-
-        mState.userSortOrder = sortOrder;
-        DirectoryFragment dir = getDirectoryFragment();
-        if (dir != null) {
-            dir.onSortOrderChanged();
-        }
-    }
-
-    /**
      * Set mode based on explicit user action.
      */
     void setViewMode(@ViewMode int mode) {
diff --git a/src/com/android/documentsui/DirectoryLoader.java b/src/com/android/documentsui/DirectoryLoader.java
index d2e918c..995c050 100644
--- a/src/com/android/documentsui/DirectoryLoader.java
+++ b/src/com/android/documentsui/DirectoryLoader.java
@@ -16,12 +16,6 @@
 
 package com.android.documentsui;
 
-import static com.android.documentsui.Shared.DEBUG;
-import static com.android.documentsui.Shared.TAG;
-import static com.android.documentsui.State.SORT_ORDER_DISPLAY_NAME;
-import static com.android.documentsui.State.SORT_ORDER_LAST_MODIFIED;
-import static com.android.documentsui.State.SORT_ORDER_SIZE;
-
 import android.content.AsyncTaskLoader;
 import android.content.ContentProviderClient;
 import android.content.ContentResolver;
@@ -35,9 +29,9 @@
 import android.provider.DocumentsContract.Document;
 import android.util.Log;
 
-import com.android.documentsui.dirlist.DirectoryFragment;
 import com.android.documentsui.model.DocumentInfo;
 import com.android.documentsui.model.RootInfo;
+import com.android.documentsui.sorting.SortModel;
 
 import libcore.io.IoUtils;
 
@@ -45,6 +39,8 @@
 
 public class DirectoryLoader extends AsyncTaskLoader<DirectoryResult> {
 
+    private static final String TAG = "DirectoryLoader";
+
     private static final String[] SEARCH_REJECT_MIMES = new String[] { Document.MIME_TYPE_DIR };
 
     private final ForceLoadContentObserver mObserver = new ForceLoadContentObserver();
@@ -52,7 +48,7 @@
     private final int mType;
     private final RootInfo mRoot;
     private final Uri mUri;
-    private final int mUserSortOrder;
+    private final SortModel mModel;
     private final boolean mSearchMode;
 
     private DocumentInfo mDoc;
@@ -60,12 +56,12 @@
     private DirectoryResult mResult;
 
     public DirectoryLoader(Context context, int type, RootInfo root, DocumentInfo doc, Uri uri,
-            int userSortOrder, boolean inSearchMode) {
+            SortModel model, boolean inSearchMode) {
         super(context, ProviderExecutor.forAuthority(root.authority));
         mType = type;
         mRoot = root;
         mUri = uri;
-        mUserSortOrder = userSortOrder;
+        mModel = model;
         mDoc = doc;
         mSearchMode = inSearchMode;
     }
@@ -84,6 +80,7 @@
 
         final DirectoryResult result = new DirectoryResult();
         result.doc = mDoc;
+        result.sortModel = mModel;
 
         // Use default document when searching
         if (mSearchMode) {
@@ -98,30 +95,12 @@
             }
         }
 
-        if (mUserSortOrder != State.SORT_ORDER_UNKNOWN) {
-            result.sortOrder = mUserSortOrder;
-        } else {
-            if ((mDoc.flags & Document.FLAG_DIR_PREFERS_LAST_MODIFIED) != 0) {
-                result.sortOrder = State.SORT_ORDER_LAST_MODIFIED;
-            } else {
-                result.sortOrder = State.SORT_ORDER_DISPLAY_NAME;
-            }
-        }
-
-        // Search always uses ranking from provider
-        if (mSearchMode) {
-            result.sortOrder = State.SORT_ORDER_UNKNOWN;
-        }
-
-        if (DEBUG)
-                Log.d(TAG, "userSortOrder=" + mUserSortOrder + ", sortOrder=" + result.sortOrder);
-
         ContentProviderClient client = null;
-        Cursor cursor = null;
+        Cursor cursor;
         try {
             client = DocumentsApplication.acquireUnstableProviderOrThrow(resolver, authority);
             cursor = client.query(
-                    mUri, null, null, null, getQuerySortOrder(result.sortOrder), mSignal);
+                    mUri, null, null, null, mModel.getDocumentSortQuery(), mSignal);
             if (cursor == null) {
                 throw new RemoteException("Provider returned null");
             }
@@ -211,17 +190,4 @@
 
         getContext().getContentResolver().unregisterContentObserver(mObserver);
     }
-
-    public static String getQuerySortOrder(int sortOrder) {
-        switch (sortOrder) {
-            case SORT_ORDER_DISPLAY_NAME:
-                return Document.COLUMN_DISPLAY_NAME + " ASC";
-            case SORT_ORDER_LAST_MODIFIED:
-                return Document.COLUMN_LAST_MODIFIED + " DESC";
-            case SORT_ORDER_SIZE:
-                return Document.COLUMN_SIZE + " DESC";
-            default:
-                return null;
-        }
-    }
 }
diff --git a/src/com/android/documentsui/DirectoryResult.java b/src/com/android/documentsui/DirectoryResult.java
index 6268643..f7ccc48 100644
--- a/src/com/android/documentsui/DirectoryResult.java
+++ b/src/com/android/documentsui/DirectoryResult.java
@@ -16,13 +16,11 @@
 
 package com.android.documentsui;
 
-import static com.android.documentsui.State.MODE_UNKNOWN;
-import static com.android.documentsui.State.SORT_ORDER_UNKNOWN;
-
 import android.content.ContentProviderClient;
 import android.database.Cursor;
 
 import com.android.documentsui.model.DocumentInfo;
+import com.android.documentsui.sorting.SortModel;
 
 import libcore.io.IoUtils;
 
@@ -31,8 +29,7 @@
     public Cursor cursor;
     public Exception exception;
     public DocumentInfo doc;
-
-    public int sortOrder = SORT_ORDER_UNKNOWN;
+    public SortModel sortModel;
 
     @Override
     public void close() {
@@ -40,5 +37,6 @@
         ContentProviderClient.releaseQuietly(client);
         cursor = null;
         client = null;
+        sortModel = null;
     }
 }
diff --git a/src/com/android/documentsui/MenuManager.java b/src/com/android/documentsui/MenuManager.java
index 0edd18e..3249183 100644
--- a/src/com/android/documentsui/MenuManager.java
+++ b/src/com/android/documentsui/MenuManager.java
@@ -53,9 +53,7 @@
         updateFileSize(menu.findItem(R.id.menu_file_size), directoryDetails);
         updateModePicker(menu.findItem(
                 R.id.menu_grid), menu.findItem(R.id.menu_list), directoryDetails);
-        updateSort(menu.findItem(R.id.menu_sort),
-                menu.findItem(R.id.menu_sort_size),
-                directoryDetails);
+        // Sort menu item is managed by SortMenuManager
         updateAdvanced(menu.findItem(R.id.menu_advanced), directoryDetails);
 
         Menus.disableHiddenItems(menu);
@@ -115,13 +113,6 @@
                 ? R.string.menu_file_size_hide : R.string.menu_file_size_show);
     }
 
-    void updateSort(MenuItem sort, MenuItem sortSize, DirectoryDetails directoryDetails) {
-        // Search uses backend ranking; no sorting, recents doesn't support sort.
-        sort.setEnabled(!directoryDetails.isInRecents() && !mSearchManager.isSearching());
-        sort.setVisible(true);
-        sortSize.setVisible(mState.getShowSize()); // Only sort by size when file sizes are visible
-    }
-
     void updateAdvanced(MenuItem advanced, DirectoryDetails directoryDetails) {
         advanced.setVisible(mState.showAdvancedOption);
         advanced.setTitle(mState.showAdvancedOption && mState.showAdvanced
diff --git a/src/com/android/documentsui/RecentsLoader.java b/src/com/android/documentsui/RecentsLoader.java
index cebc9b0..0a559ca 100644
--- a/src/com/android/documentsui/RecentsLoader.java
+++ b/src/com/android/documentsui/RecentsLoader.java
@@ -18,7 +18,6 @@
 
 import static com.android.documentsui.Shared.DEBUG;
 import static com.android.documentsui.Shared.TAG;
-import static com.android.documentsui.State.SORT_ORDER_LAST_MODIFIED;
 
 import android.app.ActivityManager;
 import android.content.AsyncTaskLoader;
@@ -37,10 +36,10 @@
 import com.android.documentsui.model.RootInfo;
 import com.android.internal.annotations.GuardedBy;
 
-import com.google.common.util.concurrent.AbstractFuture;
-
 import libcore.io.IoUtils;
 
+import com.google.common.util.concurrent.AbstractFuture;
+
 import java.io.Closeable;
 import java.io.IOException;
 import java.util.ArrayList;
@@ -82,8 +81,6 @@
     @GuardedBy("mTasks")
     private final HashMap<RootInfo, RecentsTask> mTasks = new HashMap<>();
 
-    private final int mSortOrder = State.SORT_ORDER_LAST_MODIFIED;
-
     private CountDownLatch mFirstPassLatch;
     private volatile boolean mFirstPassDone;
 
@@ -168,7 +165,7 @@
         }
 
         final DirectoryResult result = new DirectoryResult();
-        result.sortOrder = SORT_ORDER_LAST_MODIFIED;
+        result.sortModel = mState.sortModel;
 
         final Cursor merged;
         if (cursors.size() > 0) {
@@ -288,7 +285,7 @@
 
                 final Uri uri = DocumentsContract.buildRecentDocumentsUri(authority, rootId);
                 final Cursor cursor = client.query(
-                        uri, null, null, null, DirectoryLoader.getQuerySortOrder(mSortOrder));
+                        uri, null, null, null, mState.sortModel.getDocumentSortQuery());
                 mWithRoot = new RootCursorWrapper(authority, rootId, cursor, MAX_DOCS_FROM_ROOT);
 
             } catch (Exception e) {
diff --git a/src/com/android/documentsui/SearchViewManager.java b/src/com/android/documentsui/SearchViewManager.java
index 46a14e6..de2d155 100644
--- a/src/com/android/documentsui/SearchViewManager.java
+++ b/src/com/android/documentsui/SearchViewManager.java
@@ -33,6 +33,7 @@
 import android.widget.SearchView.OnQueryTextListener;
 
 import com.android.documentsui.model.RootInfo;
+import com.android.documentsui.sorting.SortModel;
 
 /**
  * Manages searching UI behavior.
@@ -58,9 +59,14 @@
     private MenuItem mMenuItem;
     private SearchView mSearchView;
 
-    public SearchViewManager(SearchManagerListener listener, @Nullable Bundle savedState) {
+    // We need to disable sorting during search.
+    private SortModel mSortModel;
+
+    public SearchViewManager(
+            SearchManagerListener listener, @Nullable Bundle savedState, SortModel sortModel) {
         mListener = listener;
         mCurrentSearch = savedState != null ? savedState.getString(Shared.EXTRA_QUERY) : null;
+        mSortModel = sortModel;
     }
 
     public void setSearchMangerListener(SearchManagerListener listener) {
@@ -186,6 +192,8 @@
             Menu menu = mActionBar.getMenu();
             menu.setGroupVisible(R.id.group_hide_when_searching, false);
         }
+
+        mSortModel.setSortEnabled(false);
     }
 
     /**
@@ -214,6 +222,8 @@
         }
         mListener.onSearchFinished();
 
+        mSortModel.setSortEnabled(true);
+
         return false;
     }
 
diff --git a/src/com/android/documentsui/State.java b/src/com/android/documentsui/State.java
index 2ee8961..5ae247d 100644
--- a/src/com/android/documentsui/State.java
+++ b/src/com/android/documentsui/State.java
@@ -74,11 +74,6 @@
     public static final int MODE_LIST = 1;
     public static final int MODE_GRID = 2;
 
-    public static final int SORT_ORDER_UNKNOWN = 0;
-    public static final int SORT_ORDER_DISPLAY_NAME = 1;
-    public static final int SORT_ORDER_LAST_MODIFIED = 2;
-    public static final int SORT_ORDER_SIZE = 3;
-
     public @ActionType int action;
     public String[] acceptMimes;
 
@@ -87,10 +82,6 @@
 
     /** Current sort state */
     public SortModel sortModel;
-    /** Explicit user choice */
-    public int userSortOrder = SORT_ORDER_UNKNOWN;
-    /** Derived after loader */
-    public int derivedSortOrder = SORT_ORDER_DISPLAY_NAME;
 
     public boolean allowMultiple;
     public boolean forceSize;
@@ -199,7 +190,6 @@
     public void writeToParcel(Parcel out, int flags) {
         out.writeInt(action);
         out.writeStringArray(acceptMimes);
-        out.writeInt(userSortOrder);
         out.writeInt(allowMultiple ? 1 : 0);
         out.writeInt(forceSize ? 1 : 0);
         out.writeInt(mShowSize ? 1 : 0);
@@ -229,7 +219,6 @@
             final State state = new State();
             state.action = in.readInt();
             state.acceptMimes = in.readStringArray();
-            state.userSortOrder = in.readInt();
             state.allowMultiple = in.readInt() != 0;
             state.forceSize = in.readInt() != 0;
             state.mShowSize = in.readInt() != 0;
diff --git a/src/com/android/documentsui/dirlist/DirectoryFragment.java b/src/com/android/documentsui/dirlist/DirectoryFragment.java
index 983d82f..65ea6c7 100644
--- a/src/com/android/documentsui/dirlist/DirectoryFragment.java
+++ b/src/com/android/documentsui/dirlist/DirectoryFragment.java
@@ -19,7 +19,6 @@
 import static com.android.documentsui.Shared.DEBUG;
 import static com.android.documentsui.State.MODE_GRID;
 import static com.android.documentsui.State.MODE_LIST;
-import static com.android.documentsui.State.SORT_ORDER_UNKNOWN;
 import static com.android.documentsui.model.DocumentInfo.getCursorInt;
 import static com.android.documentsui.model.DocumentInfo.getCursorString;
 
@@ -105,7 +104,9 @@
 import com.android.documentsui.services.FileOperationService;
 import com.android.documentsui.services.FileOperationService.OpType;
 import com.android.documentsui.services.FileOperations;
-import com.android.documentsui.sorting.SortController;
+import com.android.documentsui.sorting.SortDimension;
+import com.android.documentsui.sorting.SortDimension.SortDirection;
+import com.android.documentsui.sorting.SortModel;
 
 import java.io.IOException;
 import java.lang.annotation.Retention;
@@ -164,7 +165,8 @@
 
     private String mStateKey;
 
-    private int mLastSortOrder = SORT_ORDER_UNKNOWN;
+    private SortDimension mLastSortDimension;
+    private @SortDirection int mLastSortDirection;
     private DocumentsAdapter mAdapter;
     private FragmentTuner mTuner;
     private DocumentClipper mClipper;
@@ -195,6 +197,12 @@
     private MenuManager mMenuManager;
 
     private TableHeaderController mTableHeaderController;
+    private SortModel.UpdateListener mSortListener = (model, updateType) -> {
+        // Only when sort order has changed do we need to trigger another loading.
+        if (updateType == SortModel.UPDATE_TYPE_SORTING) {
+            getLoaderManager().restartLoader(LOADER_ID, null, this);
+        }
+    };
 
     @Override
     public View onCreateView(
@@ -344,12 +352,45 @@
         boolean svelte = am.isLowRamDevice() && (mType == TYPE_RECENT_OPEN);
         mIconHelper.setThumbnailsEnabled(!svelte);
 
-        mTuner.mSortController.manage(mTableHeaderController, getDisplayState().derivedMode);
+        // If mDocument is null, we sort it by last modified by default because it's in Recents.
+        final boolean prefersLastModified =
+                (mDocument != null)
+                        ? (mDocument.flags & Document.FLAG_DIR_PREFERS_LAST_MODIFIED) != 0
+                        : true;
+        // Call this before adding the listener to avoid restarting the loader one more time
+        state.sortModel.setDefaultDimension(
+                prefersLastModified
+                        ? SortModel.SORT_DIMENSION_ID_DATE
+                        : SortModel.SORT_DIMENSION_ID_TITLE);
 
         // Kick off loader at least once
         getLoaderManager().restartLoader(LOADER_ID, null, this);
     }
 
+    @Override
+    public void onStart() {
+        super.onStart();
+
+        mTuner.mSortController.manage(mTableHeaderController, getDisplayState().derivedMode);
+        // Add listener to update contents on sort model change
+        getDisplayState().sortModel.addListener(mSortListener);
+    }
+
+    @Override
+    public void onStop() {
+        super.onStop();
+
+        // Remove listener to avoid leak.
+        mTuner.mSortController.clean(mTableHeaderController);
+        getDisplayState().sortModel.removeListener(mSortListener);
+
+        // Remember last scroll location
+        final SparseArray<Parcelable> container = new SparseArray<Parcelable>();
+        getView().saveHierarchyState(container);
+        final State state = getDisplayState();
+        state.dirState.put(mStateKey, container);
+    }
+
     public void retainState(RetainedState state) {
         state.selection = mSelectionMgr.getSelection(new Selection());
     }
@@ -473,17 +514,6 @@
         return false;
     }
 
-    @Override
-    public void onStop() {
-        super.onStop();
-
-        // Remember last scroll location
-        final SparseArray<Parcelable> container = new SparseArray<Parcelable>();
-        getView().saveHierarchyState(container);
-        final State state = getDisplayState();
-        state.dirState.put(mStateKey, container);
-    }
-
     public void onDisplayStateChanged() {
         updateDisplayState();
     }
@@ -1655,7 +1685,7 @@
                     contentsUri = DocumentsContract.setManageMode(contentsUri);
                 }
                 return new DirectoryLoader(
-                        context, mType, mRoot, mDocument, contentsUri, state.userSortOrder,
+                        context, mType, mRoot, mDocument, contentsUri, state.sortModel,
                         mSearchMode);
             case TYPE_RECENT_OPEN:
                 final RootsCache roots = DocumentsApplication.getRootsCache(context);
@@ -1679,8 +1709,6 @@
         mAdapter.notifyDataSetChanged();
         mModel.update(result);
 
-        state.derivedSortOrder = result.sortOrder;
-
         updateLayout(state.derivedMode);
 
         if (mRestoredSelection != null) {
@@ -1692,16 +1720,20 @@
 
         // Restore any previous instance state
         final SparseArray<Parcelable> container = state.dirState.remove(mStateKey);
+        final int curSortedDimensionId = state.sortModel.getSortedDimensionId();
+        final SortDimension curSortedDimension =
+                state.sortModel.getDimensionById(curSortedDimensionId);
         if (container != null && !getArguments().getBoolean(Shared.EXTRA_IGNORE_STATE, false)) {
             getView().restoreHierarchyState(container);
-        } else if (mLastSortOrder != state.derivedSortOrder) {
-            // The derived sort order takes the user sort order into account, but applies
-            // directory-specific defaults when the user doesn't explicitly set the sort
-            // order. Scroll to the top if the sort order actually changed.
+        } else if (mLastSortDimension != curSortedDimension
+                || mLastSortDimension == null
+                || mLastSortDirection != curSortedDimension.getSortDirection()) {
+            // Scroll to the top if the sort order actually changed.
             mRecView.smoothScrollToPosition(0);
         }
 
-        mLastSortOrder = state.derivedSortOrder;
+        mLastSortDimension = curSortedDimension;
+        mLastSortDirection = curSortedDimension.getSortDirection();
 
         mTuner.onModelLoaded(mModel, mType, mSearchMode);
 
diff --git a/src/com/android/documentsui/dirlist/Model.java b/src/com/android/documentsui/dirlist/Model.java
index 5c15228..1a171bd 100644
--- a/src/com/android/documentsui/dirlist/Model.java
+++ b/src/com/android/documentsui/dirlist/Model.java
@@ -17,9 +17,6 @@
 package com.android.documentsui.dirlist;
 
 import static com.android.documentsui.Shared.DEBUG;
-import static com.android.documentsui.State.SORT_ORDER_DISPLAY_NAME;
-import static com.android.documentsui.State.SORT_ORDER_LAST_MODIFIED;
-import static com.android.documentsui.State.SORT_ORDER_SIZE;
 import static com.android.documentsui.model.DocumentInfo.getCursorLong;
 import static com.android.documentsui.model.DocumentInfo.getCursorString;
 
@@ -38,6 +35,8 @@
 import com.android.documentsui.Shared;
 import com.android.documentsui.dirlist.MultiSelectManager.Selection;
 import com.android.documentsui.model.DocumentInfo;
+import com.android.documentsui.sorting.SortDimension;
+import com.android.documentsui.sorting.SortModel;
 
 import java.util.ArrayList;
 import java.util.HashMap;
@@ -59,10 +58,10 @@
     private Map<String, Integer> mPositions = new HashMap<>();
     /**
      * A sorted array of model IDs for the files currently in the Model.  Sort order is determined
-     * by {@link #mSortOrder}
+     * by {@link #mSortModel}
      */
     private String mIds[] = new String[0];
-    private int mSortOrder = SORT_ORDER_DISPLAY_NAME;
+    private SortModel mSortModel;
 
     @Nullable String info;
     @Nullable String error;
@@ -104,7 +103,7 @@
 
         mCursor = result.cursor;
         mCursorCount = mCursor.getCount();
-        mSortOrder = result.sortOrder;
+        mSortModel = result.sortModel;
         doc = result.doc;
 
         updateModelData();
@@ -135,12 +134,13 @@
         String[] displayNames = null;
         long[] longValues = null;
 
-        switch (mSortOrder) {
-            case SORT_ORDER_DISPLAY_NAME:
+        final int id = mSortModel.getSortedDimensionId();
+        switch (id) {
+            case SortModel.SORT_DIMENSION_ID_TITLE:
                 displayNames = new String[mCursorCount];
                 break;
-            case SORT_ORDER_LAST_MODIFIED:
-            case SORT_ORDER_SIZE:
+            case SortModel.SORT_DIMENSION_ID_DATE:
+            case SortModel.SORT_DIMENSION_ID_SIZE:
                 longValues = new long[mCursorCount];
                 break;
         }
@@ -169,28 +169,29 @@
             mimeType = getCursorString(mCursor, Document.COLUMN_MIME_TYPE);
             isDirs[pos] = Document.MIME_TYPE_DIR.equals(mimeType);
 
-            switch(mSortOrder) {
-                case SORT_ORDER_DISPLAY_NAME:
+            switch(id) {
+                case SortModel.SORT_DIMENSION_ID_TITLE:
                     final String displayName = getCursorString(
                             mCursor, Document.COLUMN_DISPLAY_NAME);
                     displayNames[pos] = displayName;
                     break;
-                case SORT_ORDER_LAST_MODIFIED:
+                case SortModel.SORT_DIMENSION_ID_DATE:
                     longValues[pos] = getLastModified(mCursor);
                     break;
-                case SORT_ORDER_SIZE:
+                case SortModel.SORT_DIMENSION_ID_SIZE:
                     longValues[pos] = getCursorLong(mCursor, Document.COLUMN_SIZE);
                     break;
             }
         }
 
-        switch (mSortOrder) {
-            case SORT_ORDER_DISPLAY_NAME:
-                binarySort(displayNames, isDirs, positions, mIds);
+        final SortDimension dimension = mSortModel.getDimensionById(id);
+        switch (id) {
+            case SortModel.SORT_DIMENSION_ID_TITLE:
+                binarySort(displayNames, isDirs, positions, mIds, dimension.getSortDirection());
                 break;
-            case SORT_ORDER_LAST_MODIFIED:
-            case SORT_ORDER_SIZE:
-                binarySort(longValues, isDirs, positions, mIds);
+            case SortModel.SORT_DIMENSION_ID_DATE:
+            case SortModel.SORT_DIMENSION_ID_SIZE:
+                binarySort(longValues, isDirs, positions, mIds, dimension.getSortDirection());
                 break;
         }
 
@@ -211,7 +212,12 @@
      * @param positions Cursor positions to be sorted.
      * @param ids Model IDs to be sorted.
      */
-    private static void binarySort(String[] sortKey, boolean[] isDirs, int[] positions, String[] ids) {
+    private static void binarySort(
+            String[] sortKey,
+            boolean[] isDirs,
+            int[] positions,
+            String[] ids,
+            @SortDimension.SortDirection int direction) {
         final int count = positions.length;
         for (int start = 1; start < count; start++) {
             final int pivotPosition = positions[start];
@@ -235,7 +241,17 @@
                 } else {
                     final String lhs = pivotValue;
                     final String rhs = sortKey[mid];
-                    compare = Shared.compareToIgnoreCaseNullable(lhs, rhs);
+                    switch (direction) {
+                        case SortDimension.SORT_DIRECTION_ASCENDING:
+                            compare = Shared.compareToIgnoreCaseNullable(lhs, rhs);
+                            break;
+                        case SortDimension.SORT_DIRECTION_DESCENDING:
+                            compare = -Shared.compareToIgnoreCaseNullable(lhs, rhs);
+                            break;
+                        default:
+                            throw new IllegalArgumentException(
+                                    "Unknown sorting direction: " + direction);
+                    }
                 }
 
                 if (compare < 0) {
@@ -284,7 +300,11 @@
      * @param ids Model IDs to be sorted.
      */
     private static void binarySort(
-            long[] sortKey, boolean[] isDirs, int[] positions, String[] ids) {
+            long[] sortKey,
+            boolean[] isDirs,
+            int[] positions,
+            String[] ids,
+            @SortDimension.SortDirection int direction) {
         final int count = positions.length;
         for (int start = 1; start < count; start++) {
             final int pivotPosition = positions[start];
@@ -308,9 +328,17 @@
                 } else {
                     final long lhs = pivotValue;
                     final long rhs = sortKey[mid];
-                    // Sort in descending numerical order. This matches legacy behaviour, which
-                    // yields largest or most recent items on top.
-                    compare = -Long.compare(lhs, rhs);
+                    switch (direction) {
+                        case SortDimension.SORT_DIRECTION_ASCENDING:
+                            compare = Long.compare(lhs, rhs);
+                            break;
+                        case SortDimension.SORT_DIRECTION_DESCENDING:
+                            compare = -Long.compare(lhs, rhs);
+                            break;
+                        default:
+                            throw new IllegalArgumentException(
+                                    "Unknown sorting direction: " + direction);
+                    }
                 }
 
                 // If numerical comparison yields a tie, use document ID as a tie breaker.  This
@@ -358,7 +386,7 @@
     /**
      * @return Timestamp for the given document. Some docs (e.g. active downloads) have a null
      * timestamp - these will be replaced with MAX_LONG so that such files get sorted to the top
-     * when sorting by date.
+     * when sorting descending by date.
      */
     long getLastModified(Cursor cursor) {
         long l = getCursorLong(mCursor, Document.COLUMN_LAST_MODIFIED);
@@ -410,6 +438,14 @@
         return DocumentInfo.getUri(cursor);
     }
 
+    /**
+     * @return An ordered array of model IDs representing the documents in the model. It is sorted
+     *         according to the current sort order, which was set by the last model update.
+     */
+    public String[] getModelIds() {
+        return mIds;
+    }
+
     void addUpdateListener(UpdateListener listener) {
         mUpdateListeners.add(listener);
     }
@@ -418,7 +454,7 @@
         mUpdateListeners.remove(listener);
     }
 
-    static interface UpdateListener {
+    interface UpdateListener {
         /**
          * Called when a successful update has occurred.
          */
@@ -429,12 +465,4 @@
          */
         void onModelUpdateFailed(Exception e);
     }
-
-    /**
-     * @return An ordered array of model IDs representing the documents in the model. It is sorted
-     *         according to the current sort order, which was set by the last model update.
-     */
-    public String[] getModelIds() {
-        return mIds;
-    }
 }
diff --git a/src/com/android/documentsui/dirlist/header/TableHeaderController.java b/src/com/android/documentsui/dirlist/header/TableHeaderController.java
index 8a0074a..a48f963 100644
--- a/src/com/android/documentsui/dirlist/header/TableHeaderController.java
+++ b/src/com/android/documentsui/dirlist/header/TableHeaderController.java
@@ -22,6 +22,7 @@
 import com.android.documentsui.R;
 import com.android.documentsui.sorting.SortDimension;
 import com.android.documentsui.sorting.SortModel;
+import com.android.documentsui.sorting.SortModel.UpdateType;
 import com.android.documentsui.sorting.SortModel.SortDimensionId;
 import com.android.documentsui.sorting.SortController;
 
@@ -63,7 +64,7 @@
         mModel = model;
 
         if (mModel != null) {
-            onModelUpdate(mModel);
+            onModelUpdate(mModel, SortModel.UPDATE_TYPE_UNSPECIFIED);
 
             mModel.addListener(mModelUpdaterListener);
         }
@@ -74,7 +75,7 @@
         mTableHeader.setVisibility(visibility);
     }
 
-    private void onModelUpdate(SortModel model) {
+    private void onModelUpdate(SortModel model, @UpdateType int updateType) {
         bindCell(mTitleCell, SortModel.SORT_DIMENSION_ID_TITLE);
         bindCell(mSummaryCell, SortModel.SORT_DIMENSION_ID_SUMMARY);
         bindCell(mSizeCell, SortModel.SORT_DIMENSION_ID_SIZE);
@@ -99,6 +100,6 @@
     private void onCellClicked(View v) {
         SortDimension dimension = (SortDimension) v.getTag();
 
-        mModel.sortBy(dimension.getId(), dimension.getNextDirection());
+        mModel.sortByUser(dimension.getId(), dimension.getNextDirection());
     }
 }
diff --git a/src/com/android/documentsui/sorting/SortController.java b/src/com/android/documentsui/sorting/SortController.java
index 630b4ef..dde07d3 100644
--- a/src/com/android/documentsui/sorting/SortController.java
+++ b/src/com/android/documentsui/sorting/SortController.java
@@ -17,8 +17,10 @@
 package com.android.documentsui.sorting;
 
 import android.annotation.Nullable;
+import android.content.Context;
 import android.view.View;
 
+import com.android.documentsui.Metrics;
 import com.android.documentsui.State;
 import com.android.documentsui.dirlist.header.TableHeaderController;
 
@@ -32,24 +34,62 @@
     private static final WidgetController DUMMY_CONTROLLER = new WidgetController() {};
 
     private final SortModel mModel;
-    private WidgetController mTableHeaderController = DUMMY_CONTROLLER;
+    private final Context mContext;
 
-    public SortController(SortModel model) {
+    private WidgetController mTableHeaderController = DUMMY_CONTROLLER;
+    private WidgetController mSortMenuController = DUMMY_CONTROLLER;
+
+    public SortController(SortModel model, Context context) {
         mModel = model;
+        mContext = context.getApplicationContext();
+
+        mModel.setMetricRecorder(this::recordSortMetric);
     }
 
     public void manage(
-            @Nullable TableHeaderController tableHeaderController, @State.ViewMode int mode) {
-        if (tableHeaderController == null) {
+            @Nullable TableHeaderController controller, @State.ViewMode int mode) {
+        assert(mTableHeaderController == DUMMY_CONTROLLER);
+
+        if (controller == null) {
             return;
         }
 
-        mTableHeaderController = tableHeaderController;
+        mTableHeaderController = controller;
         mTableHeaderController.setModel(mModel);
 
         setVisibilityPerViewMode(mTableHeaderController, mode, View.GONE, View.VISIBLE);
     }
 
+    public void clean(@Nullable TableHeaderController controller) {
+        assert(controller == null || mTableHeaderController == controller);
+
+        if (controller != null) {
+            controller.setModel(null);
+        }
+
+        mTableHeaderController = DUMMY_CONTROLLER;
+    }
+
+    public void manage(SortMenuController controller) {
+        assert(mSortMenuController == DUMMY_CONTROLLER);
+
+        if (controller != null) {
+            controller.setModel(mModel);
+        }
+
+        mSortMenuController = controller;
+    }
+
+    public void clean(SortMenuController controller) {
+        assert(mSortMenuController == controller);
+
+        if (controller != null) {
+            controller.setModel(null);
+        }
+
+        mSortMenuController = DUMMY_CONTROLLER;
+    }
+
     public void onViewModeChanged(@State.ViewMode int mode) {
         setVisibilityPerViewMode(mTableHeaderController, mode, View.GONE, View.VISIBLE);
     }
@@ -71,6 +111,20 @@
         }
     }
 
+    private void recordSortMetric(SortDimension dimension) {
+        switch (dimension.getId()) {
+            case SortModel.SORT_DIMENSION_ID_TITLE:
+                Metrics.logUserAction(mContext, Metrics.USER_ACTION_SORT_NAME);
+                break;
+            case SortModel.SORT_DIMENSION_ID_SIZE:
+                Metrics.logUserAction(mContext, Metrics.USER_ACTION_SORT_SIZE);
+                break;
+            case SortModel.SORT_DIMENSION_ID_DATE:
+                Metrics.logUserAction(mContext, Metrics.USER_ACTION_SORT_DATE);
+                break;
+        }
+    }
+
     public interface WidgetController {
         default void setModel(SortModel model) {}
         default void setVisibility(int visibility) {}
diff --git a/src/com/android/documentsui/sorting/SortDimension.java b/src/com/android/documentsui/sorting/SortDimension.java
index 6881c97..9d235a1 100644
--- a/src/com/android/documentsui/sorting/SortDimension.java
+++ b/src/com/android/documentsui/sorting/SortDimension.java
@@ -124,6 +124,41 @@
     }
 
     @Override
+    public boolean equals(Object o) {
+        if (o == null || !(o instanceof SortDimension)) {
+            return false;
+        }
+
+        if (this == o) {
+            return true;
+        }
+
+        SortDimension other = (SortDimension) o;
+
+        return mId == other.mId
+                && mLabelId == other.mLabelId
+                && mDataType == other.mDataType
+                && mSortCapability == other.mSortCapability
+                && mDefaultSortDirection == other.mDefaultSortDirection
+                && mSortDirection == other.mSortDirection
+                && mVisibility == other.mVisibility;
+    }
+
+    @Override
+    public String toString() {
+        return new StringBuilder().append("SortDimension{")
+                .append("id=").append(mId)
+                .append(", labelId=").append(mLabelId)
+                .append(", dataType=").append(mDataType)
+                .append(", sortCapability=").append(mSortCapability)
+                .append(", defaultSortDirection=").append(mDefaultSortDirection)
+                .append(", sortDirection=").append(mSortDirection)
+                .append(", visibility=").append(mVisibility)
+                .append("}")
+                .toString();
+    }
+
+    @Override
     public int describeContents() {
         return 0;
     }
@@ -145,13 +180,13 @@
         @Override
         public SortDimension createFromParcel(Parcel in) {
             int id = in.readInt();
-            @StringRes int lableId = in.readInt();
+            @StringRes int labelId = in.readInt();
             @DataType  int dataType = in.readInt();
             int sortCapability = in.readInt();
             int defaultSortDirection = in.readInt();
 
             SortDimension column =
-                    new SortDimension(id, lableId, dataType, sortCapability, defaultSortDirection);
+                    new SortDimension(id, labelId, dataType, sortCapability, defaultSortDirection);
 
             column.mSortDirection = in.readInt();
             column.mVisibility = in.readInt();
diff --git a/src/com/android/documentsui/sorting/SortMenuController.java b/src/com/android/documentsui/sorting/SortMenuController.java
new file mode 100644
index 0000000..f5f9a2f
--- /dev/null
+++ b/src/com/android/documentsui/sorting/SortMenuController.java
@@ -0,0 +1,158 @@
+/*
+ * Copyright (C) 2016 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.documentsui.sorting;
+
+import android.content.res.Resources;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.SubMenu;
+import android.view.View;
+
+import com.android.documentsui.R;
+
+import java.util.Formatter;
+
+/**
+ * Displays and manages menu items related to sorting. It adds menu items for each
+ * {@link SortDimension} that supports sorting.
+ */
+public class SortMenuController implements SortController.WidgetController {
+
+    private final String mPhrase;
+    private final Resources mRes;
+
+    private final SortModel.UpdateListener mListener = this::onModelUpdate;
+    private final MenuItem.OnMenuItemClickListener mItemClickListener = this::onMenuItemClicked;
+
+    private boolean mVisible = true;
+    private MenuItem mMenu;
+    private SortModel mModel;
+
+    public SortMenuController(Resources res) {
+        mRes = res;
+        mPhrase = mRes.getString(R.string.sort_phrase);
+    }
+
+    public void install(MenuItem menu) {
+        assert(menu.hasSubMenu());
+        mMenu = menu;
+
+        initItem();
+        onModelUpdate(mModel, SortModel.UPDATE_TYPE_UNSPECIFIED);
+    }
+
+    @Override
+    public void setModel(SortModel sortModel) {
+        if (mModel != null) {
+            clearItem();
+            mModel.removeListener(mListener);
+        }
+
+        mModel = sortModel;
+
+        if (mModel != null) {
+            initItem();
+            onModelUpdate(mModel, SortModel.UPDATE_TYPE_UNSPECIFIED);
+            mModel.addListener(mListener);
+        }
+    }
+
+    @Override
+    public void setVisibility(int visibility) {
+        mVisible = (visibility == View.VISIBLE);
+        mMenu.setVisible(mVisible);
+    }
+
+    private void initItem() {
+        if (mMenu == null || mModel == null) {
+            return;
+        }
+
+        mMenu.setVisible(mVisible);
+
+        SubMenu menu = mMenu.getSubMenu();
+
+        StringBuilder builder = new StringBuilder();
+        Formatter formatter = new Formatter(builder);
+        for (int i = 0; i < mModel.getSize(); ++i) {
+            final SortDimension dimension = mModel.getDimensionAt(i);
+
+            // We don't need to add menu item if a dimension is not sortable
+            if (dimension.getSortCapability() == SortDimension.SORT_CAPABILITY_NONE) {
+                continue;
+            }
+
+            String title = formatter
+                    .format(mPhrase, mRes.getString(dimension.getLabelId()))
+                    .toString();
+
+            // Clean the underlying builder so that we can reuse it for next menu item.
+            builder.setLength(0);
+            menu.add(0, dimension.getId(), Menu.NONE, title);
+        }
+    }
+
+    private void clearItem() {
+        if (mMenu == null) {
+            return;
+        }
+
+        mMenu.getSubMenu().clear();
+    }
+
+    /**
+     * Update the state of menu items based on {@link SortModel}. Note it doesn't add or remove any
+     * menu item, but set the visibility.
+     * @param model the new model
+     */
+    private void onModelUpdate(SortModel model, @SortModel.UpdateType int updateType) {
+        // Sort menu doesn't record sort direction so there is nothing to update if only sort order
+        // has changed.
+        if (mMenu == null || updateType == SortModel.UPDATE_TYPE_SORTING) {
+            return;
+        }
+
+        mMenu.setEnabled(mModel.isSortEnabled());
+
+        SubMenu menu = mMenu.getSubMenu();
+        if (mModel.isSortEnabled()) {
+            for (int i = 0; i < menu.size(); ++i) {
+                MenuItem item = menu.getItem(i);
+                SortDimension dimension = mModel.getDimensionById(item.getItemId());
+
+                bindItem(item, dimension);
+            }
+        }
+    }
+
+    private void bindItem(MenuItem item, SortDimension dimension) {
+        item.setVisible(dimension.getVisibility() == View.VISIBLE);
+        if (dimension.getVisibility() == View.VISIBLE) {
+            item.setOnMenuItemClickListener(mItemClickListener);
+        } else {
+            item.setOnMenuItemClickListener(null);
+        }
+    }
+
+    private boolean onMenuItemClicked(MenuItem item) {
+        final SortDimension dimension = mModel.getDimensionById(item.getItemId());
+
+        // Click on menu item will only sort stuff in its default direction
+        mModel.sortByUser(dimension.getId(), dimension.getDefaultSortDirection());
+        return true;
+    }
+}
diff --git a/src/com/android/documentsui/sorting/SortModel.java b/src/com/android/documentsui/sorting/SortModel.java
index b5067fd..b812de7 100644
--- a/src/com/android/documentsui/sorting/SortModel.java
+++ b/src/com/android/documentsui/sorting/SortModel.java
@@ -16,9 +16,14 @@
 
 package com.android.documentsui.sorting;
 
+import static com.android.documentsui.Shared.DEBUG;
+
 import android.annotation.IntDef;
+import android.annotation.Nullable;
 import android.os.Parcel;
 import android.os.Parcelable;
+import android.provider.DocumentsContract.Document;
+import android.util.Log;
 import android.util.SparseArray;
 import android.view.View;
 
@@ -29,12 +34,14 @@
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
+import java.util.function.Consumer;
 
 /**
  * Sort model that contains all columns and their sorting state.
  */
 public class SortModel implements Parcelable {
     @IntDef({
+            SORT_DIMENSION_ID_UNKNOWN,
             SORT_DIMENSION_ID_TITLE,
             SORT_DIMENSION_ID_SUMMARY,
             SORT_DIMENSION_ID_DATE,
@@ -42,16 +49,48 @@
     })
     @Retention(RetentionPolicy.SOURCE)
     public @interface SortDimensionId {}
+    public static final int SORT_DIMENSION_ID_UNKNOWN = 0;
     public static final int SORT_DIMENSION_ID_TITLE = android.R.id.title;
     public static final int SORT_DIMENSION_ID_SUMMARY = android.R.id.summary;
     public static final int SORT_DIMENSION_ID_SIZE = R.id.size;
     public static final int SORT_DIMENSION_ID_DATE = R.id.date;
 
+    @IntDef({
+            UPDATE_TYPE_UNSPECIFIED,
+            UPDATE_TYPE_STATUS,
+            UPDATE_TYPE_VISIBILITY,
+            UPDATE_TYPE_SORTING
+    })
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface UpdateType {}
+    /**
+     * Default value for update type. Anything can be changed if the type is unspecified.
+     */
+    public static final int UPDATE_TYPE_UNSPECIFIED = 0;
+    /**
+     * Indicates the status of sorting has changed, i.e. whether soring is enabled.
+     */
+    public static final int UPDATE_TYPE_STATUS = 1;
+    /**
+     * Indicates the visibility of at least one dimension has changed.
+     */
+    public static final int UPDATE_TYPE_VISIBILITY = 2;
+    /**
+     * Indicates the sorting order has changed, either because the sorted dimension has changed or
+     * the sort direction has changed.
+     */
+    public static final int UPDATE_TYPE_SORTING = 3;
+
+    private static final String TAG = "SortModel";
+
     private final SparseArray<SortDimension> mDimensions;
 
     private transient final List<UpdateListener> mListeners;
+    private transient Consumer<SortDimension> mMetricRecorder;
 
-    private SortDimension mSortedDimension;
+    private int mDefaultDimensionId = SORT_DIMENSION_ID_UNKNOWN;
+    private boolean mIsUserSpecified = false;
+    private @Nullable SortDimension mSortedDimension;
 
     private boolean mIsSortEnabled = true;
 
@@ -59,6 +98,10 @@
         mDimensions = new SparseArray<>(columns.size());
 
         for (SortDimension column : columns) {
+            if (column.getId() == SORT_DIMENSION_ID_UNKNOWN) {
+                throw new IllegalArgumentException(
+                        "SortDimension id can't be " + SORT_DIMENSION_ID_UNKNOWN + ".");
+            }
             if (mDimensions.get(column.getId()) != null) {
                 throw new IllegalStateException(
                         "SortDimension id must be unique. Duplicate id: " + column.getId());
@@ -77,40 +120,87 @@
         return mDimensions.valueAt(index);
     }
 
-    public SortDimension getDimensionById(int id) {
+    public @Nullable SortDimension getDimensionById(int id) {
         return mDimensions.get(id);
     }
 
-    public SortDimension getSortedDimension() {
-        return mSortedDimension;
+    /**
+     * Gets the sorted dimension id.
+     * @return the sorted dimension id or {@link #SORT_DIMENSION_ID_UNKNOWN} if there is no sorted
+     * dimension.
+     */
+    public int getSortedDimensionId() {
+        return mSortedDimension != null ? mSortedDimension.getId() : SORT_DIMENSION_ID_UNKNOWN;
     }
 
     public void setSortEnabled(boolean enabled) {
-        if (!enabled) {
-            clearSortDirection();
-        }
         mIsSortEnabled = enabled;
 
-        notifyListeners();
+        notifyListeners(UPDATE_TYPE_STATUS);
     }
 
     public boolean isSortEnabled() {
         return mIsSortEnabled;
     }
 
-    public void sortBy(int columnId, @SortDimension.SortDirection int direction) {
+    /**
+     * Sort by the default direction of the given dimension if user has never specified any sort
+     * direction before.
+     * @param dimensionId the id of the dimension
+     */
+    public void setDefaultDimension(int dimensionId) {
+        final boolean mayNeedSorting = (mDefaultDimensionId != dimensionId);
+
+        mDefaultDimensionId = dimensionId;
+
+        if (mayNeedSorting) {
+            sortOnDefault();
+        }
+    }
+
+    void setMetricRecorder(Consumer<SortDimension> metricRecorder) {
+        mMetricRecorder = metricRecorder;
+    }
+
+    /**
+     * Sort by given dimension and direction. Should only be used when user explicitly asks to sort
+     * docs.
+     * @param dimensionId the id of the dimension
+     * @param direction the direction to sort docs in
+     */
+    public void sortByUser(int dimensionId, @SortDimension.SortDirection int direction) {
         if (!mIsSortEnabled) {
             throw new IllegalStateException("Sort is not enabled.");
         }
-        if (mDimensions.get(columnId) == null) {
-            throw new IllegalArgumentException("Unknown column id: " + columnId);
+
+        SortDimension dimension = mDimensions.get(dimensionId);
+        if (dimension == null) {
+            throw new IllegalArgumentException("Unknown column id: " + dimensionId);
         }
 
-        SortDimension newSortedDimension = mDimensions.get(columnId);
-        if ((direction & newSortedDimension.getSortCapability()) == 0) {
-            throw new IllegalStateException(
-                    "SortDimension " + columnId + " can't be sorted in direction " + direction);
+        sortByDimension(dimension, direction);
+
+        if (mMetricRecorder != null) {
+            mMetricRecorder.accept(dimension);
         }
+
+        mIsUserSpecified = true;
+    }
+
+    private void sortByDimension(
+            SortDimension newSortedDimension, @SortDimension.SortDirection int direction) {
+        if (newSortedDimension == mSortedDimension
+                && mSortedDimension.mSortDirection == direction) {
+            // Sort direction not changed, no need to proceed.
+            return;
+        }
+
+        if ((newSortedDimension.getSortCapability() & direction) == 0) {
+            throw new IllegalStateException(
+                    "Dimension with id: " + newSortedDimension.getId()
+                    + " can't be sorted in direction:" + direction);
+        }
+
         switch (direction) {
             case SortDimension.SORT_DIRECTION_ASCENDING:
             case SortDimension.SORT_DIRECTION_DESCENDING:
@@ -126,7 +216,7 @@
 
         mSortedDimension = newSortedDimension;
 
-        notifyListeners();
+        notifyListeners(UPDATE_TYPE_SORTING);
     }
 
     public void setDimensionVisibility(int columnId, int visibility) {
@@ -134,12 +224,49 @@
 
         mDimensions.get(columnId).mVisibility = visibility;
 
-        notifyListeners();
+        notifyListeners(UPDATE_TYPE_VISIBILITY);
     }
 
-    private void notifyListeners() {
+    public @Nullable String getDocumentSortQuery() {
+        final int id = getSortedDimensionId();
+        final String columnName;
+        switch (id) {
+            case SortModel.SORT_DIMENSION_ID_UNKNOWN:
+                return null;
+            case SortModel.SORT_DIMENSION_ID_TITLE:
+                columnName = Document.COLUMN_DISPLAY_NAME;
+                break;
+            case SortModel.SORT_DIMENSION_ID_DATE:
+                columnName = Document.COLUMN_LAST_MODIFIED;
+                break;
+            case SortModel.SORT_DIMENSION_ID_SIZE:
+                columnName = Document.COLUMN_SIZE;
+                break;
+            default:
+                throw new IllegalStateException(
+                        "Unexpected sort dimension id: " + id);
+        }
+
+        final SortDimension dimension = getDimensionById(id);
+        final String direction;
+        switch (dimension.getSortDirection()) {
+            case SortDimension.SORT_DIRECTION_ASCENDING:
+                direction = " ASC";
+                break;
+            case SortDimension.SORT_DIRECTION_DESCENDING:
+                direction = " DESC";
+                break;
+            default:
+                throw new IllegalStateException(
+                        "Unexpected sort direction: " + dimension.getSortDirection());
+        }
+
+        return columnName + direction;
+    }
+
+    private void notifyListeners(@UpdateType int updateType) {
         for (int i = mListeners.size() - 1; i >= 0; --i) {
-            mListeners.get(i).onModelUpdate(this);
+            mListeners.get(i).onModelUpdate(this, updateType);
         }
     }
 
@@ -156,6 +283,66 @@
             mSortedDimension.mSortDirection = SortDimension.SORT_DIRECTION_NONE;
             mSortedDimension = null;
         }
+
+        mIsUserSpecified = false;
+
+        sortOnDefault();
+    }
+
+    /**
+     * Sort by default dimension and direction if there is no history of user specifying a sort
+     * order.
+     */
+    private void sortOnDefault() {
+        if (!mIsUserSpecified) {
+            SortDimension dimension = mDimensions.get(mDefaultDimensionId);
+            if (dimension == null) {
+                if (DEBUG) Log.d(TAG, "No default sort dimension.");
+                return;
+            }
+
+            sortByDimension(dimension, dimension.getDefaultSortDirection());
+        }
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (o == null || !(o instanceof SortModel)) {
+            return false;
+        }
+
+        if (this == o) {
+            return true;
+        }
+
+        SortModel other = (SortModel) o;
+        if (mDimensions.size() != other.mDimensions.size()) {
+            return false;
+        }
+        for (int i = 0; i < mDimensions.size(); ++i) {
+            final SortDimension dimension = mDimensions.valueAt(i);
+            final int id = dimension.getId();
+            if (!dimension.equals(other.getDimensionById(id))) {
+                return false;
+            }
+        }
+
+        return mDefaultDimensionId == other.mDefaultDimensionId
+                && mIsSortEnabled == other.mIsSortEnabled
+                && (mSortedDimension == other.mSortedDimension
+                    || mSortedDimension.equals(other.mSortedDimension));
+    }
+
+    @Override
+    public String toString() {
+        return new StringBuilder()
+                .append("SortModel{")
+                .append("enabled=").append(mIsSortEnabled)
+                .append(", dimensions=").append(mDimensions)
+                .append(", defaultDimensionId=").append(mDefaultDimensionId)
+                .append(", sortedDimension=").append(mSortedDimension)
+                .append("}")
+                .toString();
     }
 
     @Override
@@ -169,18 +356,28 @@
         for (int i = 0; i < mDimensions.size(); ++i) {
             out.writeParcelable(mDimensions.valueAt(i), flag);
         }
+
+        out.writeInt(mDefaultDimensionId);
+        out.writeInt(mIsSortEnabled ? 1 : 0);
+        out.writeInt(mSortedDimension.getId());
     }
 
     public static Parcelable.Creator<SortModel> CREATOR = new Parcelable.Creator<SortModel>() {
 
         @Override
         public SortModel createFromParcel(Parcel in) {
-            int size = in.readInt();
+            final int size = in.readInt();
             Collection<SortDimension> columns = new ArrayList<>(size);
             for (int i = 0; i < size; ++i) {
                 columns.add(in.readParcelable(getClass().getClassLoader()));
             }
-            return new SortModel(columns);
+            SortModel model = new SortModel(columns);
+
+            model.mDefaultDimensionId = in.readInt();
+            model.mIsSortEnabled = (in.readInt() == 1);
+            model.mSortedDimension = model.getDimensionById(in.readInt());
+
+            return model;
         }
 
         @Override
@@ -201,7 +398,7 @@
         // Name column
         dimensions.add(builder
                 .withId(SORT_DIMENSION_ID_TITLE)
-                .withLabelId(R.string.column_name)
+                .withLabelId(R.string.sort_dimension_name)
                 .withDataType(SortDimension.DATA_TYPE_STRING)
                 .withSortCapability(SortDimension.SORT_CAPABILITY_BOTH_DIRECTION)
                 .withDefaultSortDirection(SortDimension.SORT_DIRECTION_ASCENDING)
@@ -213,7 +410,7 @@
         // Summary is only visible in Downloads and Recents root.
         dimensions.add(builder
                 .withId(SORT_DIMENSION_ID_SUMMARY)
-                .withLabelId(R.string.column_summary)
+                .withLabelId(R.string.sort_dimension_summary)
                 .withDataType(SortDimension.DATA_TYPE_STRING)
                 .withSortCapability(SortDimension.SORT_CAPABILITY_NONE)
                 .withVisibility(View.INVISIBLE)
@@ -223,7 +420,7 @@
         // Size column
         dimensions.add(builder
                 .withId(SORT_DIMENSION_ID_SIZE)
-                .withLabelId(R.string.column_size)
+                .withLabelId(R.string.sort_dimension_size)
                 .withDataType(SortDimension.DATA_TYPE_NUMBER)
                 .withSortCapability(SortDimension.SORT_CAPABILITY_BOTH_DIRECTION)
                 .withDefaultSortDirection(SortDimension.SORT_DIRECTION_ASCENDING)
@@ -234,7 +431,7 @@
         // Date column
         dimensions.add(builder
                 .withId(SORT_DIMENSION_ID_DATE)
-                .withLabelId(R.string.column_date)
+                .withLabelId(R.string.sort_dimension_date)
                 .withDataType(SortDimension.DATA_TYPE_NUMBER)
                 .withSortCapability(SortDimension.SORT_CAPABILITY_BOTH_DIRECTION)
                 .withDefaultSortDirection(SortDimension.SORT_DIRECTION_DESCENDING)
@@ -246,6 +443,6 @@
     }
 
     public interface UpdateListener {
-        void onModelUpdate(SortModel newModel);
+        void onModelUpdate(SortModel newModel, @UpdateType int updateType);
     }
 }