[go: nahoru, domu]
1/*
2 * Copyright (C) 2015 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package com.android.documentsui;
18
19import static com.android.documentsui.Shared.DEBUG;
20import static com.android.documentsui.Shared.EXTRA_BENCHMARK;
21import static com.android.documentsui.State.ACTION_CREATE;
22import static com.android.documentsui.State.ACTION_GET_CONTENT;
23import static com.android.documentsui.State.ACTION_OPEN;
24import static com.android.documentsui.State.ACTION_OPEN_TREE;
25import static com.android.documentsui.State.ACTION_PICK_COPY_DESTINATION;
26import static com.android.documentsui.State.MODE_GRID;
27
28import android.app.Activity;
29import android.app.Fragment;
30import android.app.FragmentManager;
31import android.content.Intent;
32import android.content.pm.ApplicationInfo;
33import android.content.pm.PackageInfo;
34import android.content.pm.PackageManager;
35import android.content.pm.ProviderInfo;
36import android.database.ContentObserver;
37import android.net.Uri;
38import android.os.AsyncTask;
39import android.os.Bundle;
40import android.os.Handler;
41import android.os.MessageQueue.IdleHandler;
42import android.provider.DocumentsContract;
43import android.provider.DocumentsContract.Root;
44import android.support.annotation.CallSuper;
45import android.support.annotation.LayoutRes;
46import android.support.annotation.Nullable;
47import android.util.Log;
48import android.view.KeyEvent;
49import android.view.Menu;
50import android.view.MenuItem;
51import android.widget.Spinner;
52
53import com.android.documentsui.SearchViewManager.SearchManagerListener;
54import com.android.documentsui.State.ViewMode;
55import com.android.documentsui.dirlist.AnimationView;
56import com.android.documentsui.dirlist.DirectoryFragment;
57import com.android.documentsui.dirlist.Model;
58import com.android.documentsui.model.DocumentInfo;
59import com.android.documentsui.model.DocumentStack;
60import com.android.documentsui.model.RootInfo;
61
62import java.io.FileNotFoundException;
63import java.util.ArrayList;
64import java.util.Collection;
65import java.util.Date;
66import java.util.List;
67import java.util.concurrent.Executor;
68
69public abstract class BaseActivity extends Activity
70        implements SearchManagerListener, NavigationView.Environment {
71
72    private static final String BENCHMARK_TESTING_PACKAGE = "com.android.documentsui.appperftests";
73
74    State mState;
75    RootsCache mRoots;
76    SearchViewManager mSearchManager;
77    DrawerController mDrawer;
78    NavigationView mNavigator;
79    List<EventListener> mEventListeners = new ArrayList<>();
80
81    private final String mTag;
82    private final ContentObserver mRootsCacheObserver = new ContentObserver(new Handler()) {
83        @Override
84        public void onChange(boolean selfChange) {
85            new HandleRootsChangedTask(BaseActivity.this).execute(getCurrentRoot());
86        }
87    };
88
89    @LayoutRes
90    private int mLayoutId;
91
92    private boolean mNavDrawerHasFocus;
93    private long mStartTime;
94
95    public abstract void onDocumentPicked(DocumentInfo doc, Model model);
96    public abstract void onDocumentsPicked(List<DocumentInfo> docs);
97
98    abstract void onTaskFinished(Uri... uris);
99    abstract void refreshDirectory(int anim);
100    /** Allows sub-classes to include information in a newly created State instance. */
101    abstract void includeState(State initialState);
102
103    public BaseActivity(@LayoutRes int layoutId, String tag) {
104        mLayoutId = layoutId;
105        mTag = tag;
106    }
107
108    @CallSuper
109    @Override
110    public void onCreate(Bundle icicle) {
111        // Record the time when onCreate is invoked for metric.
112        mStartTime = new Date().getTime();
113
114        super.onCreate(icicle);
115
116        final Intent intent = getIntent();
117
118        addListenerForLaunchCompletion();
119
120        setContentView(mLayoutId);
121
122        mDrawer = DrawerController.create(this);
123        mState = getState(icicle);
124        Metrics.logActivityLaunch(this, mState, intent);
125
126        mRoots = DocumentsApplication.getRootsCache(this);
127
128        getContentResolver().registerContentObserver(
129                RootsCache.sNotificationUri, false, mRootsCacheObserver);
130
131        mSearchManager = new SearchViewManager(this, icicle);
132
133        DocumentsToolbar toolbar = (DocumentsToolbar) findViewById(R.id.toolbar);
134        setActionBar(toolbar);
135        mNavigator = new NavigationView(
136                mDrawer,
137                toolbar,
138                (Spinner) findViewById(R.id.stack),
139                mState,
140                this);
141
142        // Base classes must update result in their onCreate.
143        setResult(Activity.RESULT_CANCELED);
144    }
145
146    @Override
147    public boolean onCreateOptionsMenu(Menu menu) {
148        boolean showMenu = super.onCreateOptionsMenu(menu);
149
150        getMenuInflater().inflate(R.menu.activity, menu);
151        mNavigator.update();
152        boolean fullBarSearch = getResources().getBoolean(R.bool.full_bar_search_view);
153        mSearchManager.install((DocumentsToolbar) findViewById(R.id.toolbar), fullBarSearch);
154
155        return showMenu;
156    }
157
158    @Override
159    @CallSuper
160    public boolean onPrepareOptionsMenu(Menu menu) {
161        super.onPrepareOptionsMenu(menu);
162
163        mSearchManager.showMenu(canSearchRoot());
164
165        final boolean inRecents = getCurrentDirectory() == null;
166
167        final MenuItem sort = menu.findItem(R.id.menu_sort);
168        final MenuItem sortSize = menu.findItem(R.id.menu_sort_size);
169        final MenuItem grid = menu.findItem(R.id.menu_grid);
170        final MenuItem list = menu.findItem(R.id.menu_list);
171        final MenuItem advanced = menu.findItem(R.id.menu_advanced);
172        final MenuItem fileSize = menu.findItem(R.id.menu_file_size);
173
174        // Search uses backend ranking; no sorting, recents doesn't support sort.
175        sort.setEnabled(!inRecents && !mSearchManager.isSearching());
176        sortSize.setVisible(mState.showSize); // Only sort by size when file sizes are visible
177        fileSize.setVisible(!mState.forceSize);
178
179        // grid/list is effectively a toggle.
180        grid.setVisible(mState.derivedMode != State.MODE_GRID);
181        list.setVisible(mState.derivedMode != State.MODE_LIST);
182
183        advanced.setVisible(mState.showAdvancedOption);
184        advanced.setTitle(mState.showAdvancedOption && mState.showAdvanced
185                ? R.string.menu_advanced_hide : R.string.menu_advanced_show);
186        fileSize.setTitle(LocalPreferences.getDisplayFileSize(this)
187                ? R.string.menu_file_size_hide : R.string.menu_file_size_show);
188
189        return true;
190    }
191
192    @Override
193    protected void onDestroy() {
194        getContentResolver().unregisterContentObserver(mRootsCacheObserver);
195        super.onDestroy();
196    }
197
198    private State getState(@Nullable Bundle icicle) {
199        if (icicle != null) {
200            State state = icicle.<State>getParcelable(Shared.EXTRA_STATE);
201            if (DEBUG) Log.d(mTag, "Recovered existing state object: " + state);
202            return state;
203        }
204
205        State state = new State();
206
207        final Intent intent = getIntent();
208
209        state.localOnly = intent.getBooleanExtra(Intent.EXTRA_LOCAL_ONLY, false);
210        state.forceSize = intent.getBooleanExtra(DocumentsContract.EXTRA_SHOW_FILESIZE, false);
211        state.showSize = state.forceSize || LocalPreferences.getDisplayFileSize(this);
212        state.initAcceptMimes(intent);
213        state.excludedAuthorities = getExcludedAuthorities();
214
215        includeState(state);
216
217        // Advanced roots are shown by default without menu option if forced by config or intent.
218        boolean forceAdvanced = Shared.shouldShowDeviceRoot(this, intent);
219        boolean chosenAdvanced = LocalPreferences.getShowDeviceRoot(this, state.action);
220        state.showAdvanced = forceAdvanced || chosenAdvanced;
221
222        // Menu option is shown for whitelisted intents if advanced roots are not shown by default.
223        state.showAdvancedOption = !forceAdvanced && (
224                Shared.shouldShowFancyFeatures(this)
225                || state.action == ACTION_OPEN
226                || state.action == ACTION_CREATE
227                || state.action == ACTION_OPEN_TREE
228                || state.action == ACTION_PICK_COPY_DESTINATION
229                || state.action == ACTION_GET_CONTENT);
230
231        if (DEBUG) Log.d(mTag, "Created new state object: " + state);
232
233        return state;
234    }
235
236    public void setRootsDrawerOpen(boolean open) {
237        mNavigator.revealRootsDrawer(open);
238    }
239
240    void onRootPicked(RootInfo root) {
241        // Clicking on the current root removes search
242        mSearchManager.cancelSearch();
243
244        // Skip refreshing if root nor directory didn't change
245        if (root.equals(getCurrentRoot()) && mState.stack.size() == 1) {
246            return;
247        }
248
249        mState.derivedMode = LocalPreferences.getViewMode(this, root, MODE_GRID);
250
251        // Clear entire backstack and start in new root
252        mState.onRootChanged(root);
253
254        // Recents is always in memory, so we just load it directly.
255        // Otherwise we delegate loading data from disk to a task
256        // to ensure a responsive ui.
257        if (mRoots.isRecentsRoot(root)) {
258            refreshCurrentRootAndDirectory(AnimationView.ANIM_NONE);
259        } else {
260            new PickRootTask(this, root).executeOnExecutor(getExecutorForCurrentDirectory());
261        }
262    }
263
264    @Override
265    public boolean onOptionsItemSelected(MenuItem item) {
266
267        switch (item.getItemId()) {
268            case android.R.id.home:
269                onBackPressed();
270                return true;
271
272            case R.id.menu_create_dir:
273                showCreateDirectoryDialog();
274                return true;
275
276            case R.id.menu_search:
277                // SearchViewManager listens for this directly.
278                return false;
279
280            case R.id.menu_sort_name:
281                setUserSortOrder(State.SORT_ORDER_DISPLAY_NAME);
282                return true;
283
284            case R.id.menu_sort_date:
285                setUserSortOrder(State.SORT_ORDER_LAST_MODIFIED);
286                return true;
287
288            case R.id.menu_sort_size:
289                setUserSortOrder(State.SORT_ORDER_SIZE);
290                return true;
291
292            case R.id.menu_grid:
293                setViewMode(State.MODE_GRID);
294                return true;
295
296            case R.id.menu_list:
297                setViewMode(State.MODE_LIST);
298                return true;
299
300            case R.id.menu_paste_from_clipboard:
301                DirectoryFragment dir = getDirectoryFragment();
302                if (dir != null) {
303                    dir.pasteFromClipboard();
304                }
305                return true;
306
307            case R.id.menu_advanced:
308                setDisplayAdvancedDevices(!mState.showAdvanced);
309                return true;
310
311            case R.id.menu_file_size:
312                setDisplayFileSize(!LocalPreferences.getDisplayFileSize(this));
313                return true;
314
315            case R.id.menu_settings:
316                Metrics.logUserAction(this, Metrics.USER_ACTION_SETTINGS);
317
318                final RootInfo root = getCurrentRoot();
319                final Intent intent = new Intent(DocumentsContract.ACTION_DOCUMENT_ROOT_SETTINGS);
320                intent.setDataAndType(root.getUri(), DocumentsContract.Root.MIME_TYPE_ITEM);
321                startActivity(intent);
322                return true;
323
324            default:
325                return super.onOptionsItemSelected(item);
326        }
327    }
328
329    final @Nullable DirectoryFragment getDirectoryFragment() {
330        return DirectoryFragment.get(getFragmentManager());
331    }
332
333    void showCreateDirectoryDialog() {
334        Metrics.logUserAction(this, Metrics.USER_ACTION_CREATE_DIR);
335
336        CreateDirectoryFragment.show(getFragmentManager());
337    }
338
339    void onDirectoryCreated(DocumentInfo doc) {
340        // By default we do nothing, just let the new directory appear.
341        // DocumentsActivity auto-opens directories after creating them
342        // As that is more attuned to the "picker" use cases it supports.
343    }
344
345    /**
346     * Returns true if a directory can be created in the current location.
347     * @return
348     */
349    boolean canCreateDirectory() {
350        final RootInfo root = getCurrentRoot();
351        final DocumentInfo cwd = getCurrentDirectory();
352        return cwd != null
353                && cwd.isCreateSupported()
354                && !mSearchManager.isSearching()
355                && !root.isRecents()
356                && !root.isDownloads();
357    }
358
359    void openContainerDocument(DocumentInfo doc) {
360        assert(doc.isContainer());
361
362        notifyDirectoryNavigated(doc.derivedUri);
363
364        mState.pushDocument(doc);
365        // Show an opening animation only if pressing "back" would get us back to the
366        // previous directory. Especially after opening a root document, pressing
367        // back, wouldn't go to the previous root, but close the activity.
368        final int anim = (mState.hasLocationChanged() && mState.stack.size() > 1)
369                ? AnimationView.ANIM_ENTER : AnimationView.ANIM_NONE;
370        refreshCurrentRootAndDirectory(anim);
371    }
372
373    /**
374     * Refreshes the content of the director and the menu/action bar.
375     * The current directory name and selection will get updated.
376     * @param anim
377     */
378    @Override
379    public final void refreshCurrentRootAndDirectory(int anim) {
380        mSearchManager.cancelSearch();
381
382        refreshDirectory(anim);
383
384        final RootsFragment roots = RootsFragment.get(getFragmentManager());
385        if (roots != null) {
386            roots.onCurrentRootChanged();
387        }
388
389        mNavigator.update();
390        invalidateOptionsMenu();
391    }
392
393    final void loadRoot(final Uri uri) {
394        new LoadRootTask(this, uri).executeOnExecutor(
395                ProviderExecutor.forAuthority(uri.getAuthority()));
396    }
397
398    /**
399     * Called when search results changed.
400     * Refreshes the content of the directory. It doesn't refresh elements on the action bar.
401     * e.g. The current directory name displayed on the action bar won't get updated.
402     */
403    @Override
404    public void onSearchChanged(@Nullable String query) {
405        // We should not get here if root is not searchable
406        assert(canSearchRoot());
407        reloadSearch(query);
408    }
409
410    @Override
411    public void onSearchFinished() {
412        // Restores menu icons state
413        invalidateOptionsMenu();
414    }
415
416    private void reloadSearch(String query) {
417        FragmentManager fm = getFragmentManager();
418        RootInfo root = getCurrentRoot();
419        DocumentInfo cwd = getCurrentDirectory();
420
421        DirectoryFragment.reloadSearch(fm, root, cwd, query);
422    }
423
424    final List<String> getExcludedAuthorities() {
425        List<String> authorities = new ArrayList<>();
426        if (getIntent().getBooleanExtra(DocumentsContract.EXTRA_EXCLUDE_SELF, false)) {
427            // Exclude roots provided by the calling package.
428            String packageName = getCallingPackageMaybeExtra();
429            try {
430                PackageInfo pkgInfo = getPackageManager().getPackageInfo(packageName,
431                        PackageManager.GET_PROVIDERS);
432                for (ProviderInfo provider: pkgInfo.providers) {
433                    authorities.add(provider.authority);
434                }
435            } catch (PackageManager.NameNotFoundException e) {
436                Log.e(mTag, "Calling package name does not resolve: " + packageName);
437            }
438        }
439        return authorities;
440    }
441
442    boolean canSearchRoot() {
443        final RootInfo root = getCurrentRoot();
444        return (root.flags & Root.FLAG_SUPPORTS_SEARCH) != 0;
445    }
446
447    final String getCallingPackageMaybeExtra() {
448        String callingPackage = getCallingPackage();
449        // System apps can set the calling package name using an extra.
450        try {
451            ApplicationInfo info = getPackageManager().getApplicationInfo(callingPackage, 0);
452            if (info.isSystemApp() || info.isUpdatedSystemApp()) {
453                final String extra = getIntent().getStringExtra(DocumentsContract.EXTRA_PACKAGE_NAME);
454                if (extra != null) {
455                    callingPackage = extra;
456                }
457            }
458        } finally {
459            return callingPackage;
460        }
461    }
462
463    public static BaseActivity get(Fragment fragment) {
464        return (BaseActivity) fragment.getActivity();
465    }
466
467    public State getDisplayState() {
468        return mState;
469    }
470
471    /*
472     * Get the default directory to be presented after starting the activity.
473     * Method can be overridden if the change of the behavior of the the child activity is needed.
474     */
475    public Uri getDefaultRoot() {
476        return Shared.shouldShowDocumentsRoot(this, getIntent())
477                ? DocumentsContract.buildHomeUri()
478                : DocumentsContract.buildRootUri(
479                        "com.android.providers.downloads.documents", "downloads");
480    }
481
482    /**
483     * Set internal storage visible based on explicit user action.
484     */
485    void setDisplayAdvancedDevices(boolean display) {
486        Metrics.logUserAction(this,
487                display ? Metrics.USER_ACTION_SHOW_ADVANCED : Metrics.USER_ACTION_HIDE_ADVANCED);
488
489        LocalPreferences.setShowDeviceRoot(this, mState.action, display);
490        mState.showAdvanced = display;
491        RootsFragment.get(getFragmentManager()).onDisplayStateChanged();
492        invalidateOptionsMenu();
493    }
494
495    /**
496     * Set file size visible based on explicit user action.
497     */
498    void setDisplayFileSize(boolean display) {
499        Metrics.logUserAction(this,
500                display ? Metrics.USER_ACTION_SHOW_SIZE : Metrics.USER_ACTION_HIDE_SIZE);
501
502        LocalPreferences.setDisplayFileSize(this, display);
503        mState.showSize = display;
504        DirectoryFragment dir = getDirectoryFragment();
505        if (dir != null) {
506            dir.onDisplayStateChanged();
507        }
508        invalidateOptionsMenu();
509    }
510
511    /**
512     * Set state sort order based on explicit user action.
513     */
514    void setUserSortOrder(int sortOrder) {
515        switch(sortOrder) {
516            case State.SORT_ORDER_DISPLAY_NAME:
517                Metrics.logUserAction(this, Metrics.USER_ACTION_SORT_NAME);
518                break;
519            case State.SORT_ORDER_LAST_MODIFIED:
520                Metrics.logUserAction(this, Metrics.USER_ACTION_SORT_DATE);
521                break;
522            case State.SORT_ORDER_SIZE:
523                Metrics.logUserAction(this, Metrics.USER_ACTION_SORT_SIZE);
524                break;
525        }
526
527        mState.userSortOrder = sortOrder;
528        DirectoryFragment dir = getDirectoryFragment();
529        if (dir != null) {
530            dir.onSortOrderChanged();
531        }
532    }
533
534    /**
535     * Set mode based on explicit user action.
536     */
537    void setViewMode(@ViewMode int mode) {
538        if (mode == State.MODE_GRID) {
539            Metrics.logUserAction(this, Metrics.USER_ACTION_GRID);
540        } else if (mode == State.MODE_LIST) {
541            Metrics.logUserAction(this, Metrics.USER_ACTION_LIST);
542        }
543
544        LocalPreferences.setViewMode(this, getCurrentRoot(), mode);
545        mState.derivedMode = mode;
546
547        // view icon needs to be updated, but we *could* do it
548        // in onOptionsItemSelected, and not do the full invalidation
549        // But! That's a larger refactoring we'll save for another day.
550        invalidateOptionsMenu();
551        DirectoryFragment dir = getDirectoryFragment();
552        if (dir != null) {
553            dir.onViewModeChanged();
554        }
555    }
556
557    public void setPending(boolean pending) {
558        final SaveFragment save = SaveFragment.get(getFragmentManager());
559        if (save != null) {
560            save.setPending(pending);
561        }
562    }
563
564    @Override
565    protected void onSaveInstanceState(Bundle state) {
566        super.onSaveInstanceState(state);
567        state.putParcelable(Shared.EXTRA_STATE, mState);
568        mSearchManager.onSaveInstanceState(state);
569    }
570
571    @Override
572    protected void onRestoreInstanceState(Bundle state) {
573        super.onRestoreInstanceState(state);
574    }
575
576    @Override
577    public boolean isSearchExpanded() {
578        return mSearchManager.isExpanded();
579    }
580
581    @Override
582    public RootInfo getCurrentRoot() {
583        if (mState.stack.root != null) {
584            return mState.stack.root;
585        } else {
586            return mRoots.getRecentsRoot();
587        }
588    }
589
590    public DocumentInfo getCurrentDirectory() {
591        return mState.stack.peek();
592    }
593
594    public Executor getExecutorForCurrentDirectory() {
595        final DocumentInfo cwd = getCurrentDirectory();
596        if (cwd != null && cwd.authority != null) {
597            return ProviderExecutor.forAuthority(cwd.authority);
598        } else {
599            return AsyncTask.THREAD_POOL_EXECUTOR;
600        }
601    }
602
603    @Override
604    public void onBackPressed() {
605        // While action bar is expanded, the state stack UI is hidden.
606        if (mSearchManager.cancelSearch()) {
607            return;
608        }
609
610        DirectoryFragment dir = getDirectoryFragment();
611        if (dir != null && dir.onBackPressed()) {
612            return;
613        }
614
615        if (!mState.hasLocationChanged()) {
616            super.onBackPressed();
617            return;
618        }
619
620        if (onBeforePopDir() || popDir()) {
621            return;
622        }
623
624        super.onBackPressed();
625    }
626
627    boolean onBeforePopDir() {
628        // Files app overrides this with some fancy logic.
629        return false;
630    }
631
632    public void onStackPicked(DocumentStack stack) {
633        try {
634            // Update the restored stack to ensure we have freshest data
635            stack.updateDocuments(getContentResolver());
636            mState.setStack(stack);
637            refreshCurrentRootAndDirectory(AnimationView.ANIM_SIDE);
638
639        } catch (FileNotFoundException e) {
640            Log.w(mTag, "Failed to restore stack: " + e);
641        }
642    }
643
644    /**
645     * Declare a global key handler to route key events when there isn't a specific focus view. This
646     * covers the scenario where a user opens DocumentsUI and just starts typing.
647     *
648     * @param keyCode
649     * @param event
650     * @return
651     */
652    @CallSuper
653    @Override
654    public boolean onKeyDown(int keyCode, KeyEvent event) {
655        if (Events.isNavigationKeyCode(keyCode)) {
656            // Forward all unclaimed navigation keystrokes to the DirectoryFragment. This causes any
657            // stray navigation keystrokes focus the content pane, which is probably what the user
658            // is trying to do.
659            DirectoryFragment df = DirectoryFragment.get(getFragmentManager());
660            if (df != null) {
661                df.requestFocus();
662                return true;
663            }
664        } else if (keyCode == KeyEvent.KEYCODE_TAB) {
665            // Tab toggles focus on the navigation drawer.
666            toggleNavDrawerFocus();
667            return true;
668        } else if (keyCode == KeyEvent.KEYCODE_DEL) {
669            popDir();
670            return true;
671        }
672        return super.onKeyDown(keyCode, event);
673    }
674
675    public void addEventListener(EventListener listener) {
676        mEventListeners.add(listener);
677    }
678
679    public void removeEventListener(EventListener listener) {
680        mEventListeners.remove(listener);
681    }
682
683    public void notifyDirectoryLoaded(Uri uri) {
684        for (EventListener listener : mEventListeners) {
685            listener.onDirectoryLoaded(uri);
686        }
687    }
688
689    void notifyDirectoryNavigated(Uri uri) {
690        for (EventListener listener : mEventListeners) {
691            listener.onDirectoryNavigated(uri);
692        }
693    }
694
695    /**
696     * Toggles focus between the navigation drawer and the directory listing. If the drawer isn't
697     * locked, open/close it as appropriate.
698     */
699    void toggleNavDrawerFocus() {
700        if (mNavDrawerHasFocus) {
701            mDrawer.setOpen(false);
702            DirectoryFragment df = DirectoryFragment.get(getFragmentManager());
703            if (df != null) {
704                df.requestFocus();
705            }
706        } else {
707            mDrawer.setOpen(true);
708            RootsFragment rf = RootsFragment.get(getFragmentManager());
709            if (rf != null) {
710                rf.requestFocus();
711            }
712        }
713        mNavDrawerHasFocus = !mNavDrawerHasFocus;
714    }
715
716    DocumentInfo getRootDocumentBlocking(RootInfo root) {
717        try {
718            final Uri uri = DocumentsContract.buildDocumentUri(
719                    root.authority, root.documentId);
720            return DocumentInfo.fromUri(getContentResolver(), uri);
721        } catch (FileNotFoundException e) {
722            Log.w(mTag, "Failed to find root", e);
723            return null;
724        }
725    }
726
727    /**
728     * Pops the top entry off the directory stack, and returns the user to the previous directory.
729     * If the directory stack only contains one item, this method does nothing.
730     *
731     * @return Whether the stack was popped.
732     */
733    private boolean popDir() {
734        if (mState.stack.size() > 1) {
735            mState.stack.pop();
736            refreshCurrentRootAndDirectory(AnimationView.ANIM_LEAVE);
737            return true;
738        }
739        return false;
740    }
741
742    /**
743     * Closes the activity when it's idle.
744     */
745    private void addListenerForLaunchCompletion() {
746        addEventListener(new EventListener() {
747            @Override
748            public void onDirectoryNavigated(Uri uri) {
749            }
750
751            @Override
752            public void onDirectoryLoaded(Uri uri) {
753                removeEventListener(this);
754                getMainLooper().getQueue().addIdleHandler(new IdleHandler() {
755                    @Override
756                    public boolean queueIdle() {
757                        // If startup benchmark is requested by a whitelisted testing package, then
758                        // close the activity once idle, and notify the testing activity.
759                        if (getIntent().getBooleanExtra(EXTRA_BENCHMARK, false) &&
760                                BENCHMARK_TESTING_PACKAGE.equals(getCallingPackage())) {
761                            setResult(RESULT_OK);
762                            finish();
763                        }
764
765                        Metrics.logStartupMs(
766                                BaseActivity.this, (int) (new Date().getTime() - mStartTime));
767
768                        // Remove the idle handler.
769                        return false;
770                    }
771                });
772                new Handler().post(new Runnable() {
773                    @Override public void run() {
774                    }
775                });
776            }
777        });
778    }
779
780    private static final class PickRootTask extends PairedTask<BaseActivity, Void, DocumentInfo> {
781        private RootInfo mRoot;
782
783        public PickRootTask(BaseActivity activity, RootInfo root) {
784            super(activity);
785            mRoot = root;
786        }
787
788        @Override
789        protected DocumentInfo run(Void... params) {
790            return mOwner.getRootDocumentBlocking(mRoot);
791        }
792
793        @Override
794        protected void finish(DocumentInfo result) {
795            if (result != null) {
796                mOwner.openContainerDocument(result);
797            }
798        }
799    }
800
801    private static final class HandleRootsChangedTask
802            extends PairedTask<BaseActivity, RootInfo, RootInfo> {
803        RootInfo mCurrentRoot;
804        DocumentInfo mDefaultRootDocument;
805
806        public HandleRootsChangedTask(BaseActivity activity) {
807            super(activity);
808        }
809
810        @Override
811        protected RootInfo run(RootInfo... roots) {
812            assert(roots.length == 1);
813            mCurrentRoot = roots[0];
814            final Collection<RootInfo> cachedRoots = mOwner.mRoots.getRootsBlocking();
815            for (final RootInfo root : cachedRoots) {
816                if (root.getUri().equals(mCurrentRoot.getUri())) {
817                    // We don't need to change the current root as the current root was not removed.
818                    return null;
819                }
820            }
821
822            // Choose the default root.
823            final RootInfo defaultRoot = mOwner.mRoots.getDefaultRootBlocking(mOwner.mState);
824            assert(defaultRoot != null);
825            if (!defaultRoot.isRecents()) {
826                mDefaultRootDocument = mOwner.getRootDocumentBlocking(defaultRoot);
827            }
828            return defaultRoot;
829        }
830
831        @Override
832        protected void finish(RootInfo defaultRoot) {
833            if (defaultRoot == null) {
834                return;
835            }
836
837            // If the activity has been launched for the specific root and it is removed, finish the
838            // activity.
839            final Uri uri = mOwner.getIntent().getData();
840            if (uri != null && uri.equals(mCurrentRoot.getUri())) {
841                mOwner.finish();
842                return;
843            }
844
845            // Clear entire backstack and start in new root.
846            mOwner.mState.onRootChanged(defaultRoot);
847            mOwner.mSearchManager.update(defaultRoot);
848
849            if (defaultRoot.isRecents()) {
850                mOwner.refreshCurrentRootAndDirectory(AnimationView.ANIM_NONE);
851            } else {
852                mOwner.openContainerDocument(mDefaultRootDocument);
853            }
854        }
855    }
856}
857