DirectoryFragment.java revision ef3e2cf35fbede340d5ff830b410baea8e461a94 
1/*
2 * Copyright (C) 2013 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.BaseActivity.State.ACTION_BROWSE;
20import static com.android.documentsui.BaseActivity.State.ACTION_BROWSE_ALL;
21import static com.android.documentsui.BaseActivity.State.ACTION_CREATE;
22import static com.android.documentsui.BaseActivity.State.ACTION_MANAGE;
23import static com.android.documentsui.BaseActivity.State.MODE_GRID;
24import static com.android.documentsui.BaseActivity.State.MODE_LIST;
25import static com.android.documentsui.BaseActivity.State.MODE_UNKNOWN;
26import static com.android.documentsui.BaseActivity.State.SORT_ORDER_UNKNOWN;
27import static com.android.documentsui.DocumentsActivity.TAG;
28import static com.android.documentsui.model.DocumentInfo.getCursorInt;
29import static com.android.documentsui.model.DocumentInfo.getCursorLong;
30import static com.android.documentsui.model.DocumentInfo.getCursorString;
31import android.app.Activity;
32import android.app.ActivityManager;
33import android.app.Fragment;
34import android.app.FragmentManager;
35import android.app.FragmentTransaction;
36import android.app.LoaderManager.LoaderCallbacks;
37import android.content.ContentProviderClient;
38import android.content.ContentResolver;
39import android.content.ContentValues;
40import android.content.Context;
41import android.content.Intent;
42import android.content.Loader;
43import android.content.res.Resources;
44import android.database.Cursor;
45import android.graphics.Bitmap;
46import android.graphics.Point;
47import android.graphics.drawable.Drawable;
48import android.graphics.drawable.InsetDrawable;
49import android.net.Uri;
50import android.os.AsyncTask;
51import android.os.Bundle;
52import android.os.CancellationSignal;
53import android.os.OperationCanceledException;
54import android.os.Parcelable;
55import android.provider.DocumentsContract;
56import android.provider.DocumentsContract.Document;
57import android.text.format.DateUtils;
58import android.text.format.Formatter;
59import android.text.format.Time;
60import android.util.Log;
61import android.util.SparseArray;
62import android.util.SparseBooleanArray;
63import android.view.ActionMode;
64import android.view.LayoutInflater;
65import android.view.Menu;
66import android.view.MenuItem;
67import android.view.View;
68import android.view.ViewGroup;
69import android.widget.AbsListView;
70import android.widget.AbsListView.MultiChoiceModeListener;
71import android.widget.AbsListView.RecyclerListener;
72import android.widget.AdapterView;
73import android.widget.AdapterView.OnItemClickListener;
74import android.widget.BaseAdapter;
75import android.widget.GridView;
76import android.widget.ImageView;
77import android.widget.ListView;
78import android.widget.TextView;
79import android.widget.Toast;
80
81import com.android.documentsui.BaseActivity.State;
82import com.android.documentsui.ProviderExecutor.Preemptable;
83import com.android.documentsui.RecentsProvider.StateColumns;
84import com.android.documentsui.model.DocumentInfo;
85import com.android.documentsui.model.RootInfo;
86import com.google.android.collect.Lists;
87
88import java.util.ArrayList;
89import java.util.List;
90
91/**
92 * Display the documents inside a single directory.
93 */
94public class DirectoryFragment extends Fragment {
95
96    private View mEmptyView;
97    private ListView mListView;
98    private GridView mGridView;
99
100    private AbsListView mCurrentView;
101
102    public static final int TYPE_NORMAL = 1;
103    public static final int TYPE_SEARCH = 2;
104    public static final int TYPE_RECENT_OPEN = 3;
105
106    public static final int ANIM_NONE = 1;
107    public static final int ANIM_SIDE = 2;
108    public static final int ANIM_DOWN = 3;
109    public static final int ANIM_UP = 4;
110
111    public static final int REQUEST_COPY_DESTINATION = 1;
112
113    private int mType = TYPE_NORMAL;
114    private String mStateKey;
115
116    private int mLastMode = MODE_UNKNOWN;
117    private int mLastSortOrder = SORT_ORDER_UNKNOWN;
118    private boolean mLastShowSize = false;
119
120    private boolean mHideGridTitles = false;
121
122    private boolean mSvelteRecents;
123    private Point mThumbSize;
124
125    private DocumentsAdapter mAdapter;
126    private LoaderCallbacks<DirectoryResult> mCallbacks;
127
128    private static final String EXTRA_TYPE = "type";
129    private static final String EXTRA_ROOT = "root";
130    private static final String EXTRA_DOC = "doc";
131    private static final String EXTRA_QUERY = "query";
132    private static final String EXTRA_IGNORE_STATE = "ignoreState";
133
134    private final int mLoaderId = 42;
135
136    public static void showNormal(FragmentManager fm, RootInfo root, DocumentInfo doc, int anim) {
137        show(fm, TYPE_NORMAL, root, doc, null, anim);
138    }
139
140    public static void showSearch(FragmentManager fm, RootInfo root, String query, int anim) {
141        show(fm, TYPE_SEARCH, root, null, query, anim);
142    }
143
144    public static void showRecentsOpen(FragmentManager fm, int anim) {
145        show(fm, TYPE_RECENT_OPEN, null, null, null, anim);
146    }
147
148    private static void show(FragmentManager fm, int type, RootInfo root, DocumentInfo doc,
149            String query, int anim) {
150        final Bundle args = new Bundle();
151        args.putInt(EXTRA_TYPE, type);
152        args.putParcelable(EXTRA_ROOT, root);
153        args.putParcelable(EXTRA_DOC, doc);
154        args.putString(EXTRA_QUERY, query);
155
156        final FragmentTransaction ft = fm.beginTransaction();
157        switch (anim) {
158            case ANIM_SIDE:
159                args.putBoolean(EXTRA_IGNORE_STATE, true);
160                break;
161            case ANIM_DOWN:
162                args.putBoolean(EXTRA_IGNORE_STATE, true);
163                ft.setCustomAnimations(R.animator.dir_down, R.animator.dir_frozen);
164                break;
165            case ANIM_UP:
166                ft.setCustomAnimations(R.animator.dir_frozen, R.animator.dir_up);
167                break;
168        }
169
170        final DirectoryFragment fragment = new DirectoryFragment();
171        fragment.setArguments(args);
172
173        ft.replace(R.id.container_directory, fragment);
174        ft.commitAllowingStateLoss();
175    }
176
177    private static String buildStateKey(RootInfo root, DocumentInfo doc) {
178        final StringBuilder builder = new StringBuilder();
179        builder.append(root != null ? root.authority : "null").append(';');
180        builder.append(root != null ? root.rootId : "null").append(';');
181        builder.append(doc != null ? doc.documentId : "null");
182        return builder.toString();
183    }
184
185    public static DirectoryFragment get(FragmentManager fm) {
186        // TODO: deal with multiple directories shown at once
187        return (DirectoryFragment) fm.findFragmentById(R.id.container_directory);
188    }
189
190    @Override
191    public View onCreateView(
192            LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
193        final Context context = inflater.getContext();
194        final Resources res = context.getResources();
195        final View view = inflater.inflate(R.layout.fragment_directory, container, false);
196
197        mEmptyView = view.findViewById(android.R.id.empty);
198
199        mListView = (ListView) view.findViewById(R.id.list);
200        mListView.setOnItemClickListener(mItemListener);
201        mListView.setMultiChoiceModeListener(mMultiListener);
202        mListView.setRecyclerListener(mRecycleListener);
203
204        // Indent our list divider to align with text
205        final Drawable divider = mListView.getDivider();
206        final boolean insetLeft = res.getBoolean(R.bool.list_divider_inset_left);
207        final int insetSize = res.getDimensionPixelSize(R.dimen.list_divider_inset);
208        if (insetLeft) {
209            mListView.setDivider(new InsetDrawable(divider, insetSize, 0, 0, 0));
210        } else {
211            mListView.setDivider(new InsetDrawable(divider, 0, 0, insetSize, 0));
212        }
213
214        mGridView = (GridView) view.findViewById(R.id.grid);
215        mGridView.setOnItemClickListener(mItemListener);
216        mGridView.setMultiChoiceModeListener(mMultiListener);
217        mGridView.setRecyclerListener(mRecycleListener);
218
219        return view;
220    }
221
222    @Override
223    public void onDestroyView() {
224        super.onDestroyView();
225
226        // Cancel any outstanding thumbnail requests
227        final ViewGroup target = (mListView.getAdapter() != null) ? mListView : mGridView;
228        final int count = target.getChildCount();
229        for (int i = 0; i < count; i++) {
230            final View view = target.getChildAt(i);
231            mRecycleListener.onMovedToScrapHeap(view);
232        }
233
234        // Tear down any selection in progress
235        mListView.setChoiceMode(AbsListView.CHOICE_MODE_NONE);
236        mGridView.setChoiceMode(AbsListView.CHOICE_MODE_NONE);
237    }
238
239    @Override
240    public void onActivityCreated(Bundle savedInstanceState) {
241        super.onActivityCreated(savedInstanceState);
242
243        final Context context = getActivity();
244        final State state = getDisplayState(DirectoryFragment.this);
245
246        final RootInfo root = getArguments().getParcelable(EXTRA_ROOT);
247        final DocumentInfo doc = getArguments().getParcelable(EXTRA_DOC);
248
249        mAdapter = new DocumentsAdapter();
250        mType = getArguments().getInt(EXTRA_TYPE);
251        mStateKey = buildStateKey(root, doc);
252
253        if (mType == TYPE_RECENT_OPEN) {
254            // Hide titles when showing recents for picking images/videos
255            mHideGridTitles = MimePredicate.mimeMatches(
256                    MimePredicate.VISUAL_MIMES, state.acceptMimes);
257        } else {
258            mHideGridTitles = (doc != null) && doc.isGridTitlesHidden();
259        }
260
261        final ActivityManager am = (ActivityManager) context.getSystemService(
262                Context.ACTIVITY_SERVICE);
263        mSvelteRecents = am.isLowRamDevice() && (mType == TYPE_RECENT_OPEN);
264
265        mCallbacks = new LoaderCallbacks<DirectoryResult>() {
266            @Override
267            public Loader<DirectoryResult> onCreateLoader(int id, Bundle args) {
268                final String query = getArguments().getString(EXTRA_QUERY);
269
270                Uri contentsUri;
271                switch (mType) {
272                    case TYPE_NORMAL:
273                        contentsUri = DocumentsContract.buildChildDocumentsUri(
274                                doc.authority, doc.documentId);
275                        if (state.action == ACTION_MANAGE) {
276                            contentsUri = DocumentsContract.setManageMode(contentsUri);
277                        }
278                        return new DirectoryLoader(
279                                context, mType, root, doc, contentsUri, state.userSortOrder);
280                    case TYPE_SEARCH:
281                        contentsUri = DocumentsContract.buildSearchDocumentsUri(
282                                root.authority, root.rootId, query);
283                        if (state.action == ACTION_MANAGE) {
284                            contentsUri = DocumentsContract.setManageMode(contentsUri);
285                        }
286                        return new DirectoryLoader(
287                                context, mType, root, doc, contentsUri, state.userSortOrder);
288                    case TYPE_RECENT_OPEN:
289                        final RootsCache roots = DocumentsApplication.getRootsCache(context);
290                        return new RecentLoader(context, roots, state);
291                    default:
292                        throw new IllegalStateException("Unknown type " + mType);
293                }
294            }
295
296            @Override
297            public void onLoadFinished(Loader<DirectoryResult> loader, DirectoryResult result) {
298                if (!isAdded()) return;
299
300                mAdapter.swapResult(result);
301
302                // Push latest state up to UI
303                // TODO: if mode change was racing with us, don't overwrite it
304                if (result.mode != MODE_UNKNOWN) {
305                    state.derivedMode = result.mode;
306                }
307                state.derivedSortOrder = result.sortOrder;
308                ((BaseActivity) context).onStateChanged();
309
310                updateDisplayState();
311
312                // When launched into empty recents, show drawer
313                if (mType == TYPE_RECENT_OPEN && mAdapter.isEmpty() && !state.stackTouched &&
314                        context instanceof DocumentsActivity) {
315                    ((DocumentsActivity) context).setRootsDrawerOpen(true);
316                }
317
318                // Restore any previous instance state
319                final SparseArray<Parcelable> container = state.dirState.remove(mStateKey);
320                if (container != null && !getArguments().getBoolean(EXTRA_IGNORE_STATE, false)) {
321                    getView().restoreHierarchyState(container);
322                } else if (mLastSortOrder != state.derivedSortOrder) {
323                    mListView.smoothScrollToPosition(0);
324                    mGridView.smoothScrollToPosition(0);
325                }
326
327                mLastSortOrder = state.derivedSortOrder;
328            }
329
330            @Override
331            public void onLoaderReset(Loader<DirectoryResult> loader) {
332                mAdapter.swapResult(null);
333            }
334        };
335
336        // Kick off loader at least once
337        getLoaderManager().restartLoader(mLoaderId, null, mCallbacks);
338
339        updateDisplayState();
340    }
341
342    @Override
343    public void onActivityResult(int requestCode, int resultCode, Intent data) {
344        final Context context = getActivity();
345        final Resources res = context.getResources();
346
347        // There's only one request code right now. Replace this with a switch statement or
348        // something more scalable when more codes are added.
349        if (requestCode != REQUEST_COPY_DESTINATION) {
350            return;
351        }
352        if (resultCode == Activity.RESULT_CANCELED || data == null) {
353            // User pressed the back button or otherwise cancelled the destination pick. Don't
354            // proceed with the copy.
355            return;
356        }
357
358        final List<DocumentInfo> docs = getDisplayState(this).selectedDocumentsForCopy;
359        final Intent copyIntent = new Intent(context, CopyService.class);
360        copyIntent.putParcelableArrayListExtra(CopyService.EXTRA_SRC_LIST, new ArrayList<DocumentInfo>(docs));
361        copyIntent.putExtra(CopyService.EXTRA_STACK, data.getParcelableExtra(CopyService.EXTRA_STACK));
362
363        Toast.makeText(context,
364                res.getQuantityString(R.plurals.copy_begin, docs.size(), docs.size()),
365                Toast.LENGTH_SHORT).show();
366        context.startService(copyIntent);
367    }
368
369    @Override
370    public void onStop() {
371        super.onStop();
372
373        // Remember last scroll location
374        final SparseArray<Parcelable> container = new SparseArray<Parcelable>();
375        getView().saveHierarchyState(container);
376        final State state = getDisplayState(this);
377        state.dirState.put(mStateKey, container);
378    }
379
380    @Override
381    public void onResume() {
382        super.onResume();
383        updateDisplayState();
384    }
385
386    public void onDisplayStateChanged() {
387        updateDisplayState();
388    }
389
390    public void onUserSortOrderChanged() {
391        // Sort order change always triggers reload; we'll trigger state change
392        // on the flip side.
393        getLoaderManager().restartLoader(mLoaderId, null, mCallbacks);
394    }
395
396    public void onUserModeChanged() {
397        final ContentResolver resolver = getActivity().getContentResolver();
398        final State state = getDisplayState(this);
399
400        final RootInfo root = getArguments().getParcelable(EXTRA_ROOT);
401        final DocumentInfo doc = getArguments().getParcelable(EXTRA_DOC);
402
403        if (root != null && doc != null) {
404            final Uri stateUri = RecentsProvider.buildState(
405                    root.authority, root.rootId, doc.documentId);
406            final ContentValues values = new ContentValues();
407            values.put(StateColumns.MODE, state.userMode);
408
409            new AsyncTask<Void, Void, Void>() {
410                @Override
411                protected Void doInBackground(Void... params) {
412                    resolver.insert(stateUri, values);
413                    return null;
414                }
415            }.execute();
416        }
417
418        // Mode change is just visual change; no need to kick loader, and
419        // deliver change event immediately.
420        state.derivedMode = state.userMode;
421        ((BaseActivity) getActivity()).onStateChanged();
422
423        updateDisplayState();
424    }
425
426    private void updateDisplayState() {
427        final State state = getDisplayState(this);
428
429        if (mLastMode == state.derivedMode && mLastShowSize == state.showSize) return;
430        mLastMode = state.derivedMode;
431        mLastShowSize = state.showSize;
432
433        mListView.setVisibility(state.derivedMode == MODE_LIST ? View.VISIBLE : View.GONE);
434        mGridView.setVisibility(state.derivedMode == MODE_GRID ? View.VISIBLE : View.GONE);
435
436        final int choiceMode;
437        if (state.allowMultiple) {
438            choiceMode = ListView.CHOICE_MODE_MULTIPLE_MODAL;
439        } else {
440            choiceMode = ListView.CHOICE_MODE_NONE;
441        }
442
443        final int thumbSize;
444        if (state.derivedMode == MODE_GRID) {
445            thumbSize = getResources().getDimensionPixelSize(R.dimen.grid_width);
446            mListView.setAdapter(null);
447            mListView.setChoiceMode(ListView.CHOICE_MODE_NONE);
448            mGridView.setAdapter(mAdapter);
449            mGridView.setColumnWidth(getResources().getDimensionPixelSize(R.dimen.grid_width));
450            mGridView.setNumColumns(GridView.AUTO_FIT);
451            mGridView.setChoiceMode(choiceMode);
452            mCurrentView = mGridView;
453        } else if (state.derivedMode == MODE_LIST) {
454            thumbSize = getResources().getDimensionPixelSize(R.dimen.icon_size);
455            mGridView.setAdapter(null);
456            mGridView.setChoiceMode(ListView.CHOICE_MODE_NONE);
457            mListView.setAdapter(mAdapter);
458            mListView.setChoiceMode(choiceMode);
459            mCurrentView = mListView;
460        } else {
461            throw new IllegalStateException("Unknown state " + state.derivedMode);
462        }
463
464        mThumbSize = new Point(thumbSize, thumbSize);
465    }
466
467    private OnItemClickListener mItemListener = new OnItemClickListener() {
468        @Override
469        public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
470            final Cursor cursor = mAdapter.getItem(position);
471            if (cursor != null) {
472                final String docMimeType = getCursorString(cursor, Document.COLUMN_MIME_TYPE);
473                final int docFlags = getCursorInt(cursor, Document.COLUMN_FLAGS);
474                if (isDocumentEnabled(docMimeType, docFlags)) {
475                    final DocumentInfo doc = DocumentInfo.fromDirectoryCursor(cursor);
476                    ((BaseActivity) getActivity()).onDocumentPicked(doc);
477                }
478            }
479        }
480    };
481
482    private MultiChoiceModeListener mMultiListener = new MultiChoiceModeListener() {
483        @Override
484        public boolean onCreateActionMode(ActionMode mode, Menu menu) {
485            mode.getMenuInflater().inflate(R.menu.mode_directory, menu);
486            mode.setTitle(getResources()
487                    .getString(R.string.mode_selected_count, mCurrentView.getCheckedItemCount()));
488            return true;
489        }
490
491        @Override
492        public boolean onPrepareActionMode(ActionMode mode, Menu menu) {
493            final State state = getDisplayState(DirectoryFragment.this);
494
495            final MenuItem open = menu.findItem(R.id.menu_open);
496            final MenuItem share = menu.findItem(R.id.menu_share);
497            final MenuItem delete = menu.findItem(R.id.menu_delete);
498            final MenuItem copy = menu.findItem(R.id.menu_copy);
499
500            final boolean manageOrBrowse = (state.action == ACTION_MANAGE
501                    || state.action == ACTION_BROWSE || state.action == ACTION_BROWSE_ALL);
502
503            open.setVisible(!manageOrBrowse);
504            share.setVisible(manageOrBrowse);
505            delete.setVisible(manageOrBrowse);
506            copy.setVisible(manageOrBrowse);
507
508            return true;
509        }
510
511        @Override
512        public boolean onActionItemClicked(ActionMode mode, MenuItem item) {
513            final SparseBooleanArray checked = mCurrentView.getCheckedItemPositions();
514            final ArrayList<DocumentInfo> docs = Lists.newArrayList();
515            final int size = checked.size();
516            for (int i = 0; i < size; i++) {
517                if (checked.valueAt(i)) {
518                    final Cursor cursor = mAdapter.getItem(checked.keyAt(i));
519                    final DocumentInfo doc = DocumentInfo.fromDirectoryCursor(cursor);
520                    docs.add(doc);
521                }
522            }
523
524            final int id = item.getItemId();
525            if (id == R.id.menu_open) {
526                BaseActivity.get(DirectoryFragment.this).onDocumentsPicked(docs);
527                mode.finish();
528                return true;
529
530            } else if (id == R.id.menu_share) {
531                onShareDocuments(docs);
532                mode.finish();
533                return true;
534
535            } else if (id == R.id.menu_delete) {
536                onDeleteDocuments(docs);
537                mode.finish();
538                return true;
539
540            } else if (id == R.id.menu_copy) {
541                onCopyDocuments(docs);
542                mode.finish();
543                return true;
544
545            } else if (id == R.id.menu_select_all) {
546                int count = mCurrentView.getCount();
547                for (int i = 0; i < count; i++) {
548                    mCurrentView.setItemChecked(i, true);
549                }
550                updateDisplayState();
551                return true;
552
553            } else {
554                return false;
555            }
556        }
557
558        @Override
559        public void onDestroyActionMode(ActionMode mode) {
560            // ignored
561        }
562
563        @Override
564        public void onItemCheckedStateChanged(
565                ActionMode mode, int position, long id, boolean checked) {
566            if (checked) {
567                // Directories and footer items cannot be checked
568                boolean valid = false;
569
570                final Cursor cursor = mAdapter.getItem(position);
571                if (cursor != null) {
572                    final String docMimeType = getCursorString(cursor, Document.COLUMN_MIME_TYPE);
573                    final int docFlags = getCursorInt(cursor, Document.COLUMN_FLAGS);
574                    valid = isDocumentEnabled(docMimeType, docFlags);
575                }
576
577                if (!valid) {
578                    mCurrentView.setItemChecked(position, false);
579                }
580            }
581
582            mode.setTitle(getResources()
583                    .getString(R.string.mode_selected_count, mCurrentView.getCheckedItemCount()));
584        }
585    };
586
587    private RecyclerListener mRecycleListener = new RecyclerListener() {
588        @Override
589        public void onMovedToScrapHeap(View view) {
590            final ImageView iconThumb = (ImageView) view.findViewById(R.id.icon_thumb);
591            if (iconThumb != null) {
592                final ThumbnailAsyncTask oldTask = (ThumbnailAsyncTask) iconThumb.getTag();
593                if (oldTask != null) {
594                    oldTask.preempt();
595                    iconThumb.setTag(null);
596                }
597            }
598        }
599    };
600
601    private void onShareDocuments(List<DocumentInfo> docs) {
602        Intent intent;
603
604        // Filter out directories - those can't be shared.
605        List<DocumentInfo> docsForSend = Lists.newArrayList();
606        for (DocumentInfo doc: docs) {
607            if (!Document.MIME_TYPE_DIR.equals(doc.mimeType)) {
608                docsForSend.add(doc);
609            }
610        }
611
612        if (docsForSend.size() == 1) {
613            final DocumentInfo doc = docsForSend.get(0);
614
615            intent = new Intent(Intent.ACTION_SEND);
616            intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
617            intent.addCategory(Intent.CATEGORY_DEFAULT);
618            intent.setType(doc.mimeType);
619            intent.putExtra(Intent.EXTRA_STREAM, doc.derivedUri);
620
621        } else if (docsForSend.size() > 1) {
622            intent = new Intent(Intent.ACTION_SEND_MULTIPLE);
623            intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
624            intent.addCategory(Intent.CATEGORY_DEFAULT);
625
626            final ArrayList<String> mimeTypes = Lists.newArrayList();
627            final ArrayList<Uri> uris = Lists.newArrayList();
628            for (DocumentInfo doc : docsForSend) {
629                mimeTypes.add(doc.mimeType);
630                uris.add(doc.derivedUri);
631            }
632
633            intent.setType(findCommonMimeType(mimeTypes));
634            intent.putParcelableArrayListExtra(Intent.EXTRA_STREAM, uris);
635
636        } else {
637            return;
638        }
639
640        intent = Intent.createChooser(intent, getActivity().getText(R.string.share_via));
641        startActivity(intent);
642    }
643
644    private void onDeleteDocuments(List<DocumentInfo> docs) {
645        final Context context = getActivity();
646        final ContentResolver resolver = context.getContentResolver();
647
648        boolean hadTrouble = false;
649        for (DocumentInfo doc : docs) {
650            if (!doc.isDeleteSupported()) {
651                Log.w(TAG, "Skipping " + doc);
652                hadTrouble = true;
653                continue;
654            }
655
656            ContentProviderClient client = null;
657            try {
658                client = DocumentsApplication.acquireUnstableProviderOrThrow(
659                        resolver, doc.derivedUri.getAuthority());
660                DocumentsContract.deleteDocument(client, doc.derivedUri);
661            } catch (Exception e) {
662                Log.w(TAG, "Failed to delete " + doc);
663                hadTrouble = true;
664            } finally {
665                ContentProviderClient.releaseQuietly(client);
666            }
667        }
668
669        if (hadTrouble) {
670            Toast.makeText(context, R.string.toast_failed_delete, Toast.LENGTH_SHORT).show();
671        }
672    }
673
674    private void onCopyDocuments(List<DocumentInfo> docs) {
675        getDisplayState(this).selectedDocumentsForCopy = docs;
676
677        // Pop up a dialog to pick a destination.  This is inadequate but works for now.
678        // TODO: Implement a picker that is to spec.
679        final Intent intent = new Intent(
680                BaseActivity.DocumentsIntent.ACTION_OPEN_COPY_DESTINATION,
681                Uri.EMPTY,
682                getActivity(),
683                DocumentsActivity.class);
684        boolean directoryCopy = false;
685        for (DocumentInfo info : docs) {
686            if (Document.MIME_TYPE_DIR.equals(info.mimeType)) {
687                directoryCopy = true;
688                break;
689            }
690        }
691        intent.putExtra(BaseActivity.DocumentsIntent.EXTRA_DIRECTORY_COPY, directoryCopy);
692        startActivityForResult(intent, REQUEST_COPY_DESTINATION);
693    }
694
695    private static State getDisplayState(Fragment fragment) {
696        return ((BaseActivity) fragment.getActivity()).getDisplayState();
697    }
698
699    private static abstract class Footer {
700        private final int mItemViewType;
701
702        public Footer(int itemViewType) {
703            mItemViewType = itemViewType;
704        }
705
706        public abstract View getView(View convertView, ViewGroup parent);
707
708        public int getItemViewType() {
709            return mItemViewType;
710        }
711    }
712
713    private class LoadingFooter extends Footer {
714        public LoadingFooter() {
715            super(1);
716        }
717
718        @Override
719        public View getView(View convertView, ViewGroup parent) {
720            final Context context = parent.getContext();
721            final State state = getDisplayState(DirectoryFragment.this);
722
723            if (convertView == null) {
724                final LayoutInflater inflater = LayoutInflater.from(context);
725                if (state.derivedMode == MODE_LIST) {
726                    convertView = inflater.inflate(R.layout.item_loading_list, parent, false);
727                } else if (state.derivedMode == MODE_GRID) {
728                    convertView = inflater.inflate(R.layout.item_loading_grid, parent, false);
729                } else {
730                    throw new IllegalStateException();
731                }
732            }
733
734            return convertView;
735        }
736    }
737
738    private class MessageFooter extends Footer {
739        private final int mIcon;
740        private final String mMessage;
741
742        public MessageFooter(int itemViewType, int icon, String message) {
743            super(itemViewType);
744            mIcon = icon;
745            mMessage = message;
746        }
747
748        @Override
749        public View getView(View convertView, ViewGroup parent) {
750            final Context context = parent.getContext();
751            final State state = getDisplayState(DirectoryFragment.this);
752
753            if (convertView == null) {
754                final LayoutInflater inflater = LayoutInflater.from(context);
755                if (state.derivedMode == MODE_LIST) {
756                    convertView = inflater.inflate(R.layout.item_message_list, parent, false);
757                } else if (state.derivedMode == MODE_GRID) {
758                    convertView = inflater.inflate(R.layout.item_message_grid, parent, false);
759                } else {
760                    throw new IllegalStateException();
761                }
762            }
763
764            final ImageView icon = (ImageView) convertView.findViewById(android.R.id.icon);
765            final TextView title = (TextView) convertView.findViewById(android.R.id.title);
766            icon.setImageResource(mIcon);
767            title.setText(mMessage);
768            return convertView;
769        }
770    }
771
772    private class DocumentsAdapter extends BaseAdapter {
773        private Cursor mCursor;
774        private int mCursorCount;
775
776        private List<Footer> mFooters = Lists.newArrayList();
777
778        public void swapResult(DirectoryResult result) {
779            mCursor = result != null ? result.cursor : null;
780            mCursorCount = mCursor != null ? mCursor.getCount() : 0;
781
782            mFooters.clear();
783
784            final Bundle extras = mCursor != null ? mCursor.getExtras() : null;
785            if (extras != null) {
786                final String info = extras.getString(DocumentsContract.EXTRA_INFO);
787                if (info != null) {
788                    mFooters.add(new MessageFooter(2, R.drawable.ic_dialog_info, info));
789                }
790                final String error = extras.getString(DocumentsContract.EXTRA_ERROR);
791                if (error != null) {
792                    mFooters.add(new MessageFooter(3, R.drawable.ic_dialog_alert, error));
793                }
794                if (extras.getBoolean(DocumentsContract.EXTRA_LOADING, false)) {
795                    mFooters.add(new LoadingFooter());
796                }
797            }
798
799            if (result != null && result.exception != null) {
800                mFooters.add(new MessageFooter(
801                        3, R.drawable.ic_dialog_alert, getString(R.string.query_error)));
802            }
803
804            if (isEmpty()) {
805                mEmptyView.setVisibility(View.VISIBLE);
806            } else {
807                mEmptyView.setVisibility(View.GONE);
808            }
809
810            notifyDataSetChanged();
811        }
812
813        @Override
814        public View getView(int position, View convertView, ViewGroup parent) {
815            if (position < mCursorCount) {
816                return getDocumentView(position, convertView, parent);
817            } else {
818                position -= mCursorCount;
819                convertView = mFooters.get(position).getView(convertView, parent);
820                // Only the view itself is disabled; contents inside shouldn't
821                // be dimmed.
822                convertView.setEnabled(false);
823                return convertView;
824            }
825        }
826
827        private View getDocumentView(int position, View convertView, ViewGroup parent) {
828            final Context context = parent.getContext();
829            final State state = getDisplayState(DirectoryFragment.this);
830
831            final DocumentInfo doc = getArguments().getParcelable(EXTRA_DOC);
832
833            final RootsCache roots = DocumentsApplication.getRootsCache(context);
834            final ThumbnailCache thumbs = DocumentsApplication.getThumbnailsCache(
835                    context, mThumbSize);
836
837            if (convertView == null) {
838                final LayoutInflater inflater = LayoutInflater.from(context);
839                if (state.derivedMode == MODE_LIST) {
840                    convertView = inflater.inflate(R.layout.item_doc_list, parent, false);
841                } else if (state.derivedMode == MODE_GRID) {
842                    convertView = inflater.inflate(R.layout.item_doc_grid, parent, false);
843                } else {
844                    throw new IllegalStateException();
845                }
846            }
847
848            final Cursor cursor = getItem(position);
849
850            final String docAuthority = getCursorString(cursor, RootCursorWrapper.COLUMN_AUTHORITY);
851            final String docRootId = getCursorString(cursor, RootCursorWrapper.COLUMN_ROOT_ID);
852            final String docId = getCursorString(cursor, Document.COLUMN_DOCUMENT_ID);
853            final String docMimeType = getCursorString(cursor, Document.COLUMN_MIME_TYPE);
854            final String docDisplayName = getCursorString(cursor, Document.COLUMN_DISPLAY_NAME);
855            final long docLastModified = getCursorLong(cursor, Document.COLUMN_LAST_MODIFIED);
856            final int docIcon = getCursorInt(cursor, Document.COLUMN_ICON);
857            final int docFlags = getCursorInt(cursor, Document.COLUMN_FLAGS);
858            final String docSummary = getCursorString(cursor, Document.COLUMN_SUMMARY);
859            final long docSize = getCursorLong(cursor, Document.COLUMN_SIZE);
860
861            final View line1 = convertView.findViewById(R.id.line1);
862            final View line2 = convertView.findViewById(R.id.line2);
863
864            final ImageView iconMime = (ImageView) convertView.findViewById(R.id.icon_mime);
865            final ImageView iconThumb = (ImageView) convertView.findViewById(R.id.icon_thumb);
866            final TextView title = (TextView) convertView.findViewById(android.R.id.title);
867            final ImageView icon1 = (ImageView) convertView.findViewById(android.R.id.icon1);
868            final ImageView icon2 = (ImageView) convertView.findViewById(android.R.id.icon2);
869            final TextView summary = (TextView) convertView.findViewById(android.R.id.summary);
870            final TextView date = (TextView) convertView.findViewById(R.id.date);
871            final TextView size = (TextView) convertView.findViewById(R.id.size);
872
873            final ThumbnailAsyncTask oldTask = (ThumbnailAsyncTask) iconThumb.getTag();
874            if (oldTask != null) {
875                oldTask.preempt();
876                iconThumb.setTag(null);
877            }
878
879            iconMime.animate().cancel();
880            iconThumb.animate().cancel();
881
882            final boolean supportsThumbnail = (docFlags & Document.FLAG_SUPPORTS_THUMBNAIL) != 0;
883            final boolean allowThumbnail = (state.derivedMode == MODE_GRID)
884                    || MimePredicate.mimeMatches(MimePredicate.VISUAL_MIMES, docMimeType);
885            final boolean showThumbnail = supportsThumbnail && allowThumbnail && !mSvelteRecents;
886
887            final boolean enabled = isDocumentEnabled(docMimeType, docFlags);
888            final float iconAlpha = (state.derivedMode == MODE_LIST && !enabled) ? 0.5f : 1f;
889
890            boolean cacheHit = false;
891            if (showThumbnail) {
892                final Uri uri = DocumentsContract.buildDocumentUri(docAuthority, docId);
893                final Bitmap cachedResult = thumbs.get(uri);
894                if (cachedResult != null) {
895                    iconThumb.setImageBitmap(cachedResult);
896                    cacheHit = true;
897                } else {
898                    iconThumb.setImageDrawable(null);
899                    final ThumbnailAsyncTask task = new ThumbnailAsyncTask(
900                            uri, iconMime, iconThumb, mThumbSize, iconAlpha);
901                    iconThumb.setTag(task);
902                    ProviderExecutor.forAuthority(docAuthority).execute(task);
903                }
904            }
905
906            // Always throw MIME icon into place, even when a thumbnail is being
907            // loaded in background.
908            if (cacheHit) {
909                iconMime.setAlpha(0f);
910                iconMime.setImageDrawable(null);
911                iconThumb.setAlpha(1f);
912            } else {
913                iconMime.setAlpha(1f);
914                iconThumb.setAlpha(0f);
915                iconThumb.setImageDrawable(null);
916                if (docIcon != 0) {
917                    iconMime.setImageDrawable(
918                            IconUtils.loadPackageIcon(context, docAuthority, docIcon));
919                } else {
920                    iconMime.setImageDrawable(IconUtils.loadMimeIcon(
921                            context, docMimeType, docAuthority, docId, state.derivedMode));
922                }
923            }
924
925            boolean hasLine1 = false;
926            boolean hasLine2 = false;
927
928            final boolean hideTitle = (state.derivedMode == MODE_GRID) && mHideGridTitles;
929            if (!hideTitle) {
930                title.setText(docDisplayName);
931                hasLine1 = true;
932            }
933
934            Drawable iconDrawable = null;
935            if (mType == TYPE_RECENT_OPEN) {
936                // We've already had to enumerate roots before any results can
937                // be shown, so this will never block.
938                final RootInfo root = roots.getRootBlocking(docAuthority, docRootId);
939                if (state.derivedMode == MODE_GRID) {
940                    iconDrawable = root.loadGridIcon(context);
941                } else {
942                    iconDrawable = root.loadIcon(context);
943                }
944
945                if (summary != null) {
946                    final boolean alwaysShowSummary = getResources()
947                            .getBoolean(R.bool.always_show_summary);
948                    if (alwaysShowSummary) {
949                        summary.setText(root.getDirectoryString());
950                        summary.setVisibility(View.VISIBLE);
951                        hasLine2 = true;
952                    } else {
953                        if (iconDrawable != null && roots.isIconUniqueBlocking(root)) {
954                            // No summary needed if icon speaks for itself
955                            summary.setVisibility(View.INVISIBLE);
956                        } else {
957                            summary.setText(root.getDirectoryString());
958                            summary.setVisibility(View.VISIBLE);
959                            summary.setTextAlignment(TextView.TEXT_ALIGNMENT_TEXT_END);
960                            hasLine2 = true;
961                        }
962                    }
963                }
964            } else {
965                // Directories showing thumbnails in grid mode get a little icon
966                // hint to remind user they're a directory.
967                if (Document.MIME_TYPE_DIR.equals(docMimeType) && state.derivedMode == MODE_GRID
968                        && showThumbnail) {
969                    iconDrawable = IconUtils.applyTintAttr(context, R.drawable.ic_doc_folder,
970                            android.R.attr.textColorPrimaryInverse);
971                }
972
973                if (summary != null) {
974                    if (docSummary != null) {
975                        summary.setText(docSummary);
976                        summary.setVisibility(View.VISIBLE);
977                        hasLine2 = true;
978                    } else {
979                        summary.setVisibility(View.INVISIBLE);
980                    }
981                }
982            }
983
984            if (icon1 != null) icon1.setVisibility(View.GONE);
985            if (icon2 != null) icon2.setVisibility(View.GONE);
986
987            if (iconDrawable != null) {
988                if (hasLine1) {
989                    icon1.setVisibility(View.VISIBLE);
990                    icon1.setImageDrawable(iconDrawable);
991                } else {
992                    icon2.setVisibility(View.VISIBLE);
993                    icon2.setImageDrawable(iconDrawable);
994                }
995            }
996
997            if (docLastModified == -1) {
998                date.setText(null);
999            } else {
1000                date.setText(formatTime(context, docLastModified));
1001                hasLine2 = true;
1002            }
1003
1004            if (state.showSize) {
1005                size.setVisibility(View.VISIBLE);
1006                if (Document.MIME_TYPE_DIR.equals(docMimeType) || docSize == -1) {
1007                    size.setText(null);
1008                } else {
1009                    size.setText(Formatter.formatFileSize(context, docSize));
1010                    hasLine2 = true;
1011                }
1012            } else {
1013                size.setVisibility(View.GONE);
1014            }
1015
1016            if (line1 != null) {
1017                line1.setVisibility(hasLine1 ? View.VISIBLE : View.GONE);
1018            }
1019            if (line2 != null) {
1020                line2.setVisibility(hasLine2 ? View.VISIBLE : View.GONE);
1021            }
1022
1023            setEnabledRecursive(convertView, enabled);
1024
1025            iconMime.setAlpha(iconAlpha);
1026            iconThumb.setAlpha(iconAlpha);
1027            if (icon1 != null) icon1.setAlpha(iconAlpha);
1028            if (icon2 != null) icon2.setAlpha(iconAlpha);
1029
1030            return convertView;
1031        }
1032
1033        @Override
1034        public int getCount() {
1035            return mCursorCount + mFooters.size();
1036        }
1037
1038        @Override
1039        public Cursor getItem(int position) {
1040            if (position < mCursorCount) {
1041                mCursor.moveToPosition(position);
1042                return mCursor;
1043            } else {
1044                return null;
1045            }
1046        }
1047
1048        @Override
1049        public long getItemId(int position) {
1050            return position;
1051        }
1052
1053        @Override
1054        public int getViewTypeCount() {
1055            return 4;
1056        }
1057
1058        @Override
1059        public int getItemViewType(int position) {
1060            if (position < mCursorCount) {
1061                return 0;
1062            } else {
1063                position -= mCursorCount;
1064                return mFooters.get(position).getItemViewType();
1065            }
1066        }
1067    }
1068
1069    private static class ThumbnailAsyncTask extends AsyncTask<Uri, Void, Bitmap>
1070            implements Preemptable {
1071        private final Uri mUri;
1072        private final ImageView mIconMime;
1073        private final ImageView mIconThumb;
1074        private final Point mThumbSize;
1075        private final float mTargetAlpha;
1076        private final CancellationSignal mSignal;
1077
1078        public ThumbnailAsyncTask(Uri uri, ImageView iconMime, ImageView iconThumb, Point thumbSize,
1079                float targetAlpha) {
1080            mUri = uri;
1081            mIconMime = iconMime;
1082            mIconThumb = iconThumb;
1083            mThumbSize = thumbSize;
1084            mTargetAlpha = targetAlpha;
1085            mSignal = new CancellationSignal();
1086        }
1087
1088        @Override
1089        public void preempt() {
1090            cancel(false);
1091            mSignal.cancel();
1092        }
1093
1094        @Override
1095        protected Bitmap doInBackground(Uri... params) {
1096            if (isCancelled()) return null;
1097
1098            final Context context = mIconThumb.getContext();
1099            final ContentResolver resolver = context.getContentResolver();
1100
1101            ContentProviderClient client = null;
1102            Bitmap result = null;
1103            try {
1104                client = DocumentsApplication.acquireUnstableProviderOrThrow(
1105                        resolver, mUri.getAuthority());
1106                result = DocumentsContract.getDocumentThumbnail(client, mUri, mThumbSize, mSignal);
1107                if (result != null) {
1108                    final ThumbnailCache thumbs = DocumentsApplication.getThumbnailsCache(
1109                            context, mThumbSize);
1110                    thumbs.put(mUri, result);
1111                }
1112            } catch (Exception e) {
1113                if (!(e instanceof OperationCanceledException)) {
1114                    Log.w(TAG, "Failed to load thumbnail for " + mUri + ": " + e);
1115                }
1116            } finally {
1117                ContentProviderClient.releaseQuietly(client);
1118            }
1119            return result;
1120        }
1121
1122        @Override
1123        protected void onPostExecute(Bitmap result) {
1124            if (mIconThumb.getTag() == this && result != null) {
1125                mIconThumb.setTag(null);
1126                mIconThumb.setImageBitmap(result);
1127
1128                mIconMime.setAlpha(mTargetAlpha);
1129                mIconMime.animate().alpha(0f).start();
1130                mIconThumb.setAlpha(0f);
1131                mIconThumb.animate().alpha(mTargetAlpha).start();
1132            }
1133        }
1134    }
1135
1136    private static String formatTime(Context context, long when) {
1137        // TODO: DateUtils should make this easier
1138        Time then = new Time();
1139        then.set(when);
1140        Time now = new Time();
1141        now.setToNow();
1142
1143        int flags = DateUtils.FORMAT_NO_NOON | DateUtils.FORMAT_NO_MIDNIGHT
1144                | DateUtils.FORMAT_ABBREV_ALL;
1145
1146        if (then.year != now.year) {
1147            flags |= DateUtils.FORMAT_SHOW_YEAR | DateUtils.FORMAT_SHOW_DATE;
1148        } else if (then.yearDay != now.yearDay) {
1149            flags |= DateUtils.FORMAT_SHOW_DATE;
1150        } else {
1151            flags |= DateUtils.FORMAT_SHOW_TIME;
1152        }
1153
1154        return DateUtils.formatDateTime(context, when, flags);
1155    }
1156
1157    private String findCommonMimeType(List<String> mimeTypes) {
1158        String[] commonType = mimeTypes.get(0).split("/");
1159        if (commonType.length != 2) {
1160            return "*/*";
1161        }
1162
1163        for (int i = 1; i < mimeTypes.size(); i++) {
1164            String[] type = mimeTypes.get(i).split("/");
1165            if (type.length != 2) continue;
1166
1167            if (!commonType[1].equals(type[1])) {
1168                commonType[1] = "*";
1169            }
1170
1171            if (!commonType[0].equals(type[0])) {
1172                commonType[0] = "*";
1173                commonType[1] = "*";
1174                break;
1175            }
1176        }
1177
1178        return commonType[0] + "/" + commonType[1];
1179    }
1180
1181    private void setEnabledRecursive(View v, boolean enabled) {
1182        if (v == null) return;
1183        if (v.isEnabled() == enabled) return;
1184        v.setEnabled(enabled);
1185
1186        if (v instanceof ViewGroup) {
1187            final ViewGroup vg = (ViewGroup) v;
1188            for (int i = vg.getChildCount() - 1; i >= 0; i--) {
1189                setEnabledRecursive(vg.getChildAt(i), enabled);
1190            }
1191        }
1192    }
1193
1194    private boolean isDocumentEnabled(String docMimeType, int docFlags) {
1195        final State state = getDisplayState(DirectoryFragment.this);
1196
1197        // Directories are always enabled
1198        if (Document.MIME_TYPE_DIR.equals(docMimeType)) {
1199            return true;
1200        }
1201
1202        // Read-only files are disabled when creating
1203        if (state.action == ACTION_CREATE && (docFlags & Document.FLAG_SUPPORTS_WRITE) == 0) {
1204            return false;
1205        }
1206
1207        return MimePredicate.mimeMatches(state.acceptMimes, docMimeType);
1208    }
1209}
1210