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