Jeff Sharkey | e22d02e | 2013-04-26 16:54:55 -0700 | [diff] [blame] | 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 | |
| 17 | package com.android.documentsui; |
| 18 | |
Jeff Sharkey | 311a7d8 | 2015-04-11 21:27:21 -0700 | [diff] [blame] | 19 | import static com.android.documentsui.BaseActivity.State.ACTION_BROWSE; |
Steve McKay | d0a2a2c | 2015-03-25 14:35:33 -0700 | [diff] [blame] | 20 | import static com.android.documentsui.BaseActivity.State.ACTION_CREATE; |
| 21 | import static com.android.documentsui.BaseActivity.State.ACTION_GET_CONTENT; |
| 22 | import static com.android.documentsui.BaseActivity.State.ACTION_MANAGE; |
| 23 | import static com.android.documentsui.BaseActivity.State.ACTION_OPEN; |
Daichi Hirono | caadd41 | 2015-04-10 15:50:38 +0900 | [diff] [blame] | 24 | import static com.android.documentsui.BaseActivity.State.ACTION_OPEN_COPY_DESTINATION; |
Steve McKay | b68dd22 | 2015-04-20 17:18:15 -0700 | [diff] [blame] | 25 | import static com.android.documentsui.BaseActivity.State.ACTION_OPEN_TREE; |
Jeff Sharkey | 311a7d8 | 2015-04-11 21:27:21 -0700 | [diff] [blame] | 26 | import static com.android.documentsui.DirectoryFragment.ANIM_DOWN; |
| 27 | import static com.android.documentsui.DirectoryFragment.ANIM_NONE; |
Jeff Sharkey | 311a7d8 | 2015-04-11 21:27:21 -0700 | [diff] [blame] | 28 | import static com.android.documentsui.DirectoryFragment.ANIM_UP; |
| 29 | |
Steve McKay | b68dd22 | 2015-04-20 17:18:15 -0700 | [diff] [blame] | 30 | import java.util.Arrays; |
| 31 | import java.util.List; |
| 32 | |
Jeff Sharkey | e22d02e | 2013-04-26 16:54:55 -0700 | [diff] [blame] | 33 | import android.app.Activity; |
Steve McKay | b68dd22 | 2015-04-20 17:18:15 -0700 | [diff] [blame] | 34 | import android.app.Fragment; |
Jeff Sharkey | e22d02e | 2013-04-26 16:54:55 -0700 | [diff] [blame] | 35 | import android.app.FragmentManager; |
Jeff Sharkey | 873daa3 | 2013-08-18 17:38:20 -0700 | [diff] [blame] | 36 | import android.content.ActivityNotFoundException; |
Jeff Sharkey | c317af8 | 2013-07-01 16:56:54 -0700 | [diff] [blame] | 37 | import android.content.ClipData; |
Jeff Sharkey | 1d890e0 | 2013-08-15 11:24:03 -0700 | [diff] [blame] | 38 | import android.content.ComponentName; |
Jeff Sharkey | 3fd1177 | 2013-09-30 14:26:27 -0700 | [diff] [blame] | 39 | import android.content.ContentProviderClient; |
Jeff Sharkey | c317af8 | 2013-07-01 16:56:54 -0700 | [diff] [blame] | 40 | import android.content.ContentResolver; |
Jeff Sharkey | f7adc93 | 2013-07-30 17:08:39 -0700 | [diff] [blame] | 41 | import android.content.ContentValues; |
Jeff Sharkey | e6fcceb | 2014-07-28 16:38:52 -0700 | [diff] [blame] | 42 | import android.content.Context; |
Jeff Sharkey | e22d02e | 2013-04-26 16:54:55 -0700 | [diff] [blame] | 43 | import android.content.Intent; |
Jeff Sharkey | 1d890e0 | 2013-08-15 11:24:03 -0700 | [diff] [blame] | 44 | import android.content.pm.ResolveInfo; |
Jeff Sharkey | 7d58fc6 | 2013-09-12 16:25:02 -0700 | [diff] [blame] | 45 | import android.content.res.Resources; |
Jeff Sharkey | 7d58fc6 | 2013-09-12 16:25:02 -0700 | [diff] [blame] | 46 | import android.graphics.Point; |
Jeff Sharkey | e22d02e | 2013-04-26 16:54:55 -0700 | [diff] [blame] | 47 | import android.net.Uri; |
Jeff Sharkey | 8b99704 | 2013-09-19 15:25:56 -0700 | [diff] [blame] | 48 | import android.os.AsyncTask; |
Jeff Sharkey | e22d02e | 2013-04-26 16:54:55 -0700 | [diff] [blame] | 49 | import android.os.Bundle; |
Tomasz Mikolajewski | 2023fcf | 2015-04-10 10:30:33 +0900 | [diff] [blame] | 50 | import android.os.Parcelable; |
Jeff Sharkey | f339f25 | 2013-08-15 16:17:41 -0700 | [diff] [blame] | 51 | import android.provider.DocumentsContract; |
Jeff Sharkey | 0e8c871 | 2013-09-12 21:59:06 -0700 | [diff] [blame] | 52 | import android.provider.DocumentsContract.Root; |
Jeff Sharkey | 46165b5 | 2013-07-31 20:53:22 -0700 | [diff] [blame] | 53 | import android.support.v4.app.ActionBarDrawerToggle; |
Jeff Sharkey | 46165b5 | 2013-07-31 20:53:22 -0700 | [diff] [blame] | 54 | import android.support.v4.widget.DrawerLayout; |
| 55 | import android.support.v4.widget.DrawerLayout.DrawerListener; |
Jeff Sharkey | e22d02e | 2013-04-26 16:54:55 -0700 | [diff] [blame] | 56 | import android.util.Log; |
Jeff Sharkey | 09c10bf | 2013-06-30 20:02:59 -0700 | [diff] [blame] | 57 | import android.view.Menu; |
| 58 | import android.view.MenuItem; |
Jeff Sharkey | e22d02e | 2013-04-26 16:54:55 -0700 | [diff] [blame] | 59 | import android.view.View; |
Jeff Sharkey | 7d58fc6 | 2013-09-12 16:25:02 -0700 | [diff] [blame] | 60 | import android.view.WindowManager; |
Jeff Sharkey | 09c10bf | 2013-06-30 20:02:59 -0700 | [diff] [blame] | 61 | import android.widget.BaseAdapter; |
Jeff Sharkey | e6fcceb | 2014-07-28 16:38:52 -0700 | [diff] [blame] | 62 | import android.widget.Spinner; |
Jeff Sharkey | 7827821 | 2013-08-01 11:01:47 -0700 | [diff] [blame] | 63 | import android.widget.Toast; |
Jeff Sharkey | e6fcceb | 2014-07-28 16:38:52 -0700 | [diff] [blame] | 64 | import android.widget.Toolbar; |
Jeff Sharkey | e22d02e | 2013-04-26 16:54:55 -0700 | [diff] [blame] | 65 | |
Jeff Sharkey | a4d1f22 | 2013-09-07 14:45:03 -0700 | [diff] [blame] | 66 | import com.android.documentsui.RecentsProvider.RecentColumns; |
| 67 | import com.android.documentsui.RecentsProvider.ResumeColumns; |
Jeff Sharkey | 724deeb | 2013-08-31 15:02:20 -0700 | [diff] [blame] | 68 | import com.android.documentsui.model.DocumentInfo; |
Jeff Sharkey | b362044 | 2013-09-01 18:41:04 -0700 | [diff] [blame] | 69 | import com.android.documentsui.model.DurableUtils; |
Jeff Sharkey | 724deeb | 2013-08-31 15:02:20 -0700 | [diff] [blame] | 70 | import com.android.documentsui.model.RootInfo; |
Jeff Sharkey | f7adc93 | 2013-07-30 17:08:39 -0700 | [diff] [blame] | 71 | |
Steve McKay | d0a2a2c | 2015-03-25 14:35:33 -0700 | [diff] [blame] | 72 | public class DocumentsActivity extends BaseActivity { |
Steve McKay | b68dd22 | 2015-04-20 17:18:15 -0700 | [diff] [blame] | 73 | private static final int CODE_FORWARD = 42; |
Jeff Sharkey | a5defe3 | 2013-08-05 17:56:48 -0700 | [diff] [blame] | 74 | public static final String TAG = "Documents"; |
Jeff Sharkey | e22d02e | 2013-04-26 16:54:55 -0700 | [diff] [blame] | 75 | |
Jeff Sharkey | 7d58fc6 | 2013-09-12 16:25:02 -0700 | [diff] [blame] | 76 | private boolean mShowAsDialog; |
| 77 | |
Jeff Sharkey | e6fcceb | 2014-07-28 16:38:52 -0700 | [diff] [blame] | 78 | private Toolbar mToolbar; |
| 79 | private Spinner mToolbarStack; |
| 80 | |
| 81 | private Toolbar mRootsToolbar; |
| 82 | |
Jeff Sharkey | 7d58fc6 | 2013-09-12 16:25:02 -0700 | [diff] [blame] | 83 | private DrawerLayout mDrawerLayout; |
| 84 | private ActionBarDrawerToggle mDrawerToggle; |
Jeff Sharkey | e6fcceb | 2014-07-28 16:38:52 -0700 | [diff] [blame] | 85 | private View mRootsDrawer; |
Jeff Sharkey | 7d58fc6 | 2013-09-12 16:25:02 -0700 | [diff] [blame] | 86 | |
Jeff Sharkey | c8ae7a5 | 2013-09-18 16:26:49 -0700 | [diff] [blame] | 87 | private DirectoryContainerView mDirectoryContainer; |
| 88 | |
Jeff Sharkey | b362044 | 2013-09-01 18:41:04 -0700 | [diff] [blame] | 89 | private State mState; |
Jeff Sharkey | 09c10bf | 2013-06-30 20:02:59 -0700 | [diff] [blame] | 90 | |
Steve McKay | b68dd22 | 2015-04-20 17:18:15 -0700 | [diff] [blame] | 91 | private ItemSelectedListener mStackListener; |
| 92 | private BaseAdapter mStackAdapter; |
| 93 | |
| 94 | public DocumentsActivity() { |
| 95 | super(TAG); |
| 96 | } |
| 97 | |
Jeff Sharkey | e22d02e | 2013-04-26 16:54:55 -0700 | [diff] [blame] | 98 | @Override |
| 99 | public void onCreate(Bundle icicle) { |
| 100 | super.onCreate(icicle); |
| 101 | |
Jeff Sharkey | e22d02e | 2013-04-26 16:54:55 -0700 | [diff] [blame] | 102 | setResult(Activity.RESULT_CANCELED); |
Jeff Sharkey | 09c10bf | 2013-06-30 20:02:59 -0700 | [diff] [blame] | 103 | setContentView(R.layout.activity); |
| 104 | |
Jeff Sharkey | e6fcceb | 2014-07-28 16:38:52 -0700 | [diff] [blame] | 105 | final Context context = this; |
Jeff Sharkey | 7d58fc6 | 2013-09-12 16:25:02 -0700 | [diff] [blame] | 106 | final Resources res = getResources(); |
| 107 | mShowAsDialog = res.getBoolean(R.bool.show_as_dialog); |
Jeff Sharkey | 7611221 | 2013-08-06 11:26:10 -0700 | [diff] [blame] | 108 | |
Jeff Sharkey | 7d58fc6 | 2013-09-12 16:25:02 -0700 | [diff] [blame] | 109 | if (mShowAsDialog) { |
Jeff Sharkey | e6fcceb | 2014-07-28 16:38:52 -0700 | [diff] [blame] | 110 | // Strongly define our horizontal dimension; we leave vertical as |
| 111 | // WRAP_CONTENT so that system resizes us when IME is showing. |
Jeff Sharkey | 7d58fc6 | 2013-09-12 16:25:02 -0700 | [diff] [blame] | 112 | final WindowManager.LayoutParams a = getWindow().getAttributes(); |
Jeff Sharkey | 46165b5 | 2013-07-31 20:53:22 -0700 | [diff] [blame] | 113 | |
Jeff Sharkey | 7d58fc6 | 2013-09-12 16:25:02 -0700 | [diff] [blame] | 114 | final Point size = new Point(); |
| 115 | getWindowManager().getDefaultDisplay().getSize(size); |
Jeff Sharkey | e6fcceb | 2014-07-28 16:38:52 -0700 | [diff] [blame] | 116 | a.width = (int) res.getFraction(R.dimen.dialog_width, size.x, size.x); |
Jeff Sharkey | 7d58fc6 | 2013-09-12 16:25:02 -0700 | [diff] [blame] | 117 | |
Jeff Sharkey | e6fcceb | 2014-07-28 16:38:52 -0700 | [diff] [blame] | 118 | getWindow().setAttributes(a); |
Jeff Sharkey | 7d58fc6 | 2013-09-12 16:25:02 -0700 | [diff] [blame] | 119 | |
| 120 | } else { |
| 121 | // Non-dialog means we have a drawer |
| 122 | mDrawerLayout = (DrawerLayout) findViewById(R.id.drawer_layout); |
| 123 | |
| 124 | mDrawerToggle = new ActionBarDrawerToggle(this, mDrawerLayout, |
Jeff Sharkey | e6fcceb | 2014-07-28 16:38:52 -0700 | [diff] [blame] | 125 | R.drawable.ic_hamburger, R.string.drawer_open, R.string.drawer_close); |
Jeff Sharkey | 7d58fc6 | 2013-09-12 16:25:02 -0700 | [diff] [blame] | 126 | |
| 127 | mDrawerLayout.setDrawerListener(mDrawerListener); |
Jeff Sharkey | 7d58fc6 | 2013-09-12 16:25:02 -0700 | [diff] [blame] | 128 | |
Jeff Sharkey | e6fcceb | 2014-07-28 16:38:52 -0700 | [diff] [blame] | 129 | mRootsDrawer = findViewById(R.id.drawer_roots); |
Jeff Sharkey | 7d58fc6 | 2013-09-12 16:25:02 -0700 | [diff] [blame] | 130 | } |
Jeff Sharkey | 46165b5 | 2013-07-31 20:53:22 -0700 | [diff] [blame] | 131 | |
Jeff Sharkey | c8ae7a5 | 2013-09-18 16:26:49 -0700 | [diff] [blame] | 132 | mDirectoryContainer = (DirectoryContainerView) findViewById(R.id.container_directory); |
| 133 | |
Steve McKay | b68dd22 | 2015-04-20 17:18:15 -0700 | [diff] [blame] | 134 | mState = (icicle != null) |
| 135 | ? icicle.<State>getParcelable(EXTRA_STATE) |
| 136 | : buildDefaultState(); |
Jeff Sharkey | 5b53592 | 2013-08-02 15:55:26 -0700 | [diff] [blame] | 137 | |
Jeff Sharkey | e6fcceb | 2014-07-28 16:38:52 -0700 | [diff] [blame] | 138 | mToolbar = (Toolbar) findViewById(R.id.toolbar); |
| 139 | mToolbar.setTitleTextAppearance(context, |
| 140 | android.R.style.TextAppearance_DeviceDefault_Widget_ActionBar_Title); |
| 141 | |
Steve McKay | b68dd22 | 2015-04-20 17:18:15 -0700 | [diff] [blame] | 142 | mStackAdapter = new StackAdapter(); |
| 143 | mStackListener = new ItemSelectedListener(); |
Jeff Sharkey | e6fcceb | 2014-07-28 16:38:52 -0700 | [diff] [blame] | 144 | mToolbarStack = (Spinner) findViewById(R.id.stack); |
| 145 | mToolbarStack.setOnItemSelectedListener(mStackListener); |
| 146 | |
| 147 | mRootsToolbar = (Toolbar) findViewById(R.id.roots_toolbar); |
| 148 | if (mRootsToolbar != null) { |
| 149 | mRootsToolbar.setTitleTextAppearance(context, |
| 150 | android.R.style.TextAppearance_DeviceDefault_Widget_ActionBar_Title); |
| 151 | } |
| 152 | |
Jeff Sharkey | eff65d3 | 2014-07-29 16:32:36 -0700 | [diff] [blame] | 153 | setActionBar(mToolbar); |
| 154 | |
Jeff Sharkey | 7d58fc6 | 2013-09-12 16:25:02 -0700 | [diff] [blame] | 155 | // Hide roots when we're managing a specific root |
Jeff Sharkey | 311a7d8 | 2015-04-11 21:27:21 -0700 | [diff] [blame] | 156 | if (mState.action == ACTION_MANAGE || mState.action == ACTION_BROWSE) { |
Jeff Sharkey | 7d58fc6 | 2013-09-12 16:25:02 -0700 | [diff] [blame] | 157 | if (mShowAsDialog) { |
Jeff Sharkey | e6fcceb | 2014-07-28 16:38:52 -0700 | [diff] [blame] | 158 | findViewById(R.id.container_roots).setVisibility(View.GONE); |
Jeff Sharkey | 7d58fc6 | 2013-09-12 16:25:02 -0700 | [diff] [blame] | 159 | } else { |
| 160 | mDrawerLayout.setDrawerLockMode(DrawerLayout.LOCK_MODE_LOCKED_CLOSED); |
| 161 | } |
Jeff Sharkey | b362044 | 2013-09-01 18:41:04 -0700 | [diff] [blame] | 162 | } |
| 163 | |
| 164 | if (mState.action == ACTION_CREATE) { |
| 165 | final String mimeType = getIntent().getType(); |
| 166 | final String title = getIntent().getStringExtra(Intent.EXTRA_TITLE); |
| 167 | SaveFragment.show(getFragmentManager(), mimeType, title); |
Daichi Hirono | caadd41 | 2015-04-10 15:50:38 +0900 | [diff] [blame] | 168 | } else if (mState.action == ACTION_OPEN_TREE || |
| 169 | mState.action == ACTION_OPEN_COPY_DESTINATION) { |
Jeff Sharkey | 6e565ff | 2014-04-05 19:05:24 -0700 | [diff] [blame] | 170 | PickFragment.show(getFragmentManager()); |
Jeff Sharkey | b362044 | 2013-09-01 18:41:04 -0700 | [diff] [blame] | 171 | } |
| 172 | |
| 173 | if (mState.action == ACTION_GET_CONTENT) { |
| 174 | final Intent moreApps = new Intent(getIntent()); |
| 175 | moreApps.setComponent(null); |
| 176 | moreApps.setPackage(null); |
| 177 | RootsFragment.show(getFragmentManager(), moreApps); |
Daichi Hirono | caadd41 | 2015-04-10 15:50:38 +0900 | [diff] [blame] | 178 | } else if (mState.action == ACTION_OPEN || |
| 179 | mState.action == ACTION_CREATE || |
| 180 | mState.action == ACTION_OPEN_TREE || |
| 181 | mState.action == ACTION_OPEN_COPY_DESTINATION) { |
Jeff Sharkey | b362044 | 2013-09-01 18:41:04 -0700 | [diff] [blame] | 182 | RootsFragment.show(getFragmentManager(), null); |
| 183 | } |
| 184 | |
Jeff Sharkey | 8b99704 | 2013-09-19 15:25:56 -0700 | [diff] [blame] | 185 | if (!mState.restored) { |
Jeff Sharkey | 311a7d8 | 2015-04-11 21:27:21 -0700 | [diff] [blame] | 186 | if (mState.action == ACTION_MANAGE || mState.action == ACTION_BROWSE) { |
Jeff Sharkey | 8b99704 | 2013-09-19 15:25:56 -0700 | [diff] [blame] | 187 | final Uri rootUri = getIntent().getData(); |
Jeff Sharkey | f63b777 | 2013-10-01 17:57:41 -0700 | [diff] [blame] | 188 | new RestoreRootTask(rootUri).executeOnExecutor(getCurrentExecutor()); |
Jeff Sharkey | 8b99704 | 2013-09-19 15:25:56 -0700 | [diff] [blame] | 189 | } else { |
| 190 | new RestoreStackTask().execute(); |
| 191 | } |
| 192 | } else { |
| 193 | onCurrentDirectoryChanged(ANIM_NONE); |
| 194 | } |
Jeff Sharkey | b362044 | 2013-09-01 18:41:04 -0700 | [diff] [blame] | 195 | } |
| 196 | |
Steve McKay | b68dd22 | 2015-04-20 17:18:15 -0700 | [diff] [blame] | 197 | private State buildDefaultState() { |
| 198 | State state = new State(); |
Jeff Sharkey | b362044 | 2013-09-01 18:41:04 -0700 | [diff] [blame] | 199 | |
| 200 | final Intent intent = getIntent(); |
| 201 | final String action = intent.getAction(); |
| 202 | if (Intent.ACTION_OPEN_DOCUMENT.equals(action)) { |
Steve McKay | b68dd22 | 2015-04-20 17:18:15 -0700 | [diff] [blame] | 203 | state.action = ACTION_OPEN; |
Jeff Sharkey | b362044 | 2013-09-01 18:41:04 -0700 | [diff] [blame] | 204 | } else if (Intent.ACTION_CREATE_DOCUMENT.equals(action)) { |
Steve McKay | b68dd22 | 2015-04-20 17:18:15 -0700 | [diff] [blame] | 205 | state.action = ACTION_CREATE; |
Jeff Sharkey | b362044 | 2013-09-01 18:41:04 -0700 | [diff] [blame] | 206 | } else if (Intent.ACTION_GET_CONTENT.equals(action)) { |
Steve McKay | b68dd22 | 2015-04-20 17:18:15 -0700 | [diff] [blame] | 207 | state.action = ACTION_GET_CONTENT; |
Jeff Sharkey | f4943e1 | 2014-06-04 16:42:47 -0700 | [diff] [blame] | 208 | } else if (Intent.ACTION_OPEN_DOCUMENT_TREE.equals(action)) { |
Steve McKay | b68dd22 | 2015-04-20 17:18:15 -0700 | [diff] [blame] | 209 | state.action = ACTION_OPEN_TREE; |
Jeff Sharkey | 91a101c | 2013-09-05 17:14:14 -0700 | [diff] [blame] | 210 | } else if (DocumentsContract.ACTION_MANAGE_ROOT.equals(action)) { |
Steve McKay | b68dd22 | 2015-04-20 17:18:15 -0700 | [diff] [blame] | 211 | state.action = ACTION_MANAGE; |
Jeff Sharkey | 938528d | 2015-04-12 21:52:24 -0700 | [diff] [blame] | 212 | } else if (DocumentsContract.ACTION_BROWSE_DOCUMENT_ROOT.equals(action)) { |
Steve McKay | b68dd22 | 2015-04-20 17:18:15 -0700 | [diff] [blame] | 213 | state.action = ACTION_BROWSE; |
Daichi Hirono | 22574ed | 2015-04-15 13:41:18 +0900 | [diff] [blame] | 214 | } else if (DocumentsIntent.ACTION_OPEN_COPY_DESTINATION.equals(action)) { |
Steve McKay | b68dd22 | 2015-04-20 17:18:15 -0700 | [diff] [blame] | 215 | state.action = ACTION_OPEN_COPY_DESTINATION; |
Jeff Sharkey | b362044 | 2013-09-01 18:41:04 -0700 | [diff] [blame] | 216 | } |
| 217 | |
Steve McKay | b68dd22 | 2015-04-20 17:18:15 -0700 | [diff] [blame] | 218 | if (state.action == ACTION_OPEN || state.action == ACTION_GET_CONTENT) { |
| 219 | state.allowMultiple = intent.getBooleanExtra( |
Jeff Sharkey | b362044 | 2013-09-01 18:41:04 -0700 | [diff] [blame] | 220 | Intent.EXTRA_ALLOW_MULTIPLE, false); |
| 221 | } |
| 222 | |
Steve McKay | b68dd22 | 2015-04-20 17:18:15 -0700 | [diff] [blame] | 223 | if (state.action == ACTION_MANAGE || state.action == ACTION_BROWSE) { |
| 224 | state.acceptMimes = new String[] { "*/*" }; |
| 225 | state.allowMultiple = true; |
Jeff Sharkey | b362044 | 2013-09-01 18:41:04 -0700 | [diff] [blame] | 226 | } else if (intent.hasExtra(Intent.EXTRA_MIME_TYPES)) { |
Steve McKay | b68dd22 | 2015-04-20 17:18:15 -0700 | [diff] [blame] | 227 | state.acceptMimes = intent.getStringArrayExtra(Intent.EXTRA_MIME_TYPES); |
Jeff Sharkey | b362044 | 2013-09-01 18:41:04 -0700 | [diff] [blame] | 228 | } else { |
Steve McKay | b68dd22 | 2015-04-20 17:18:15 -0700 | [diff] [blame] | 229 | state.acceptMimes = new String[] { intent.getType() }; |
Jeff Sharkey | b362044 | 2013-09-01 18:41:04 -0700 | [diff] [blame] | 230 | } |
| 231 | |
Steve McKay | b68dd22 | 2015-04-20 17:18:15 -0700 | [diff] [blame] | 232 | state.localOnly = intent.getBooleanExtra(Intent.EXTRA_LOCAL_ONLY, false); |
| 233 | state.forceAdvanced = intent.getBooleanExtra(DocumentsContract.EXTRA_SHOW_ADVANCED, false); |
| 234 | state.showAdvanced = state.forceAdvanced |
Jeff Sharkey | e8d13ea | 2014-08-08 15:10:03 -0700 | [diff] [blame] | 235 | | LocalPreferences.getDisplayAdvancedDevices(this); |
| 236 | |
Steve McKay | b68dd22 | 2015-04-20 17:18:15 -0700 | [diff] [blame] | 237 | if (state.action == ACTION_MANAGE || state.action == ACTION_BROWSE) { |
| 238 | state.showSize = true; |
Jeff Sharkey | e8d13ea | 2014-08-08 15:10:03 -0700 | [diff] [blame] | 239 | } else { |
Steve McKay | b68dd22 | 2015-04-20 17:18:15 -0700 | [diff] [blame] | 240 | state.showSize = LocalPreferences.getDisplayFileSize(this); |
Jeff Sharkey | e8d13ea | 2014-08-08 15:10:03 -0700 | [diff] [blame] | 241 | } |
Steve McKay | b68dd22 | 2015-04-20 17:18:15 -0700 | [diff] [blame] | 242 | if (state.action == ACTION_OPEN_COPY_DESTINATION) { |
| 243 | state.directoryCopy = intent.getBooleanExtra( |
Daichi Hirono | 22574ed | 2015-04-15 13:41:18 +0900 | [diff] [blame] | 244 | BaseActivity.DocumentsIntent.EXTRA_DIRECTORY_COPY, false); |
Ben Kwa | cb4461f | 2015-05-05 11:50:11 -0700 | [diff] [blame^] | 245 | state.transferMode = intent.getIntExtra(CopyService.EXTRA_TRANSFER_MODE, |
| 246 | CopyService.TRANSFER_MODE_NONE); |
Daichi Hirono | f2a822d | 2015-04-14 17:12:54 +0900 | [diff] [blame] | 247 | } |
Steve McKay | b68dd22 | 2015-04-20 17:18:15 -0700 | [diff] [blame] | 248 | |
| 249 | return state; |
Jeff Sharkey | 8b99704 | 2013-09-19 15:25:56 -0700 | [diff] [blame] | 250 | } |
Jeff Sharkey | b362044 | 2013-09-01 18:41:04 -0700 | [diff] [blame] | 251 | |
Jeff Sharkey | 8b99704 | 2013-09-19 15:25:56 -0700 | [diff] [blame] | 252 | private class RestoreRootTask extends AsyncTask<Void, Void, RootInfo> { |
| 253 | private Uri mRootUri; |
| 254 | |
| 255 | public RestoreRootTask(Uri rootUri) { |
| 256 | mRootUri = rootUri; |
| 257 | } |
| 258 | |
| 259 | @Override |
| 260 | protected RootInfo doInBackground(Void... params) { |
| 261 | final String rootId = DocumentsContract.getRootId(mRootUri); |
| 262 | return mRoots.getRootOneshot(mRootUri.getAuthority(), rootId); |
| 263 | } |
| 264 | |
| 265 | @Override |
| 266 | protected void onPostExecute(RootInfo root) { |
| 267 | if (isDestroyed()) return; |
| 268 | mState.restored = true; |
| 269 | |
Jeff Sharkey | f339f25 | 2013-08-15 16:17:41 -0700 | [diff] [blame] | 270 | if (root != null) { |
Steve McKay | b68dd22 | 2015-04-20 17:18:15 -0700 | [diff] [blame] | 271 | onRootPicked(root); |
Jeff Sharkey | f339f25 | 2013-08-15 16:17:41 -0700 | [diff] [blame] | 272 | } else { |
Jeff Sharkey | 8b99704 | 2013-09-19 15:25:56 -0700 | [diff] [blame] | 273 | Log.w(TAG, "Failed to find root: " + mRootUri); |
Jeff Sharkey | f339f25 | 2013-08-15 16:17:41 -0700 | [diff] [blame] | 274 | finish(); |
Jeff Sharkey | 5b53592 | 2013-08-02 15:55:26 -0700 | [diff] [blame] | 275 | } |
Jeff Sharkey | 8b99704 | 2013-09-19 15:25:56 -0700 | [diff] [blame] | 276 | } |
| 277 | } |
Jeff Sharkey | 5b53592 | 2013-08-02 15:55:26 -0700 | [diff] [blame] | 278 | |
Steve McKay | b68dd22 | 2015-04-20 17:18:15 -0700 | [diff] [blame] | 279 | @Override |
| 280 | void onStackRestored(boolean restored, boolean external) { |
| 281 | // Show drawer when no stack restored, but only when requesting |
| 282 | // non-visual content. However, if we last used an external app, |
| 283 | // drawer is always shown. |
Jeff Sharkey | 8b99704 | 2013-09-19 15:25:56 -0700 | [diff] [blame] | 284 | |
Steve McKay | b68dd22 | 2015-04-20 17:18:15 -0700 | [diff] [blame] | 285 | boolean showDrawer = false; |
| 286 | if (!restored) { |
| 287 | showDrawer = true; |
| 288 | } |
| 289 | if (MimePredicate.mimeMatches(MimePredicate.VISUAL_MIMES, mState.acceptMimes)) { |
| 290 | showDrawer = false; |
| 291 | } |
| 292 | if (external && mState.action == ACTION_GET_CONTENT) { |
| 293 | showDrawer = true; |
Jeff Sharkey | 8b99704 | 2013-09-19 15:25:56 -0700 | [diff] [blame] | 294 | } |
| 295 | |
Steve McKay | b68dd22 | 2015-04-20 17:18:15 -0700 | [diff] [blame] | 296 | if (showDrawer) { |
| 297 | setRootsDrawerOpen(true); |
| 298 | } |
| 299 | } |
Jeff Sharkey | 8b99704 | 2013-09-19 15:25:56 -0700 | [diff] [blame] | 300 | |
Steve McKay | b68dd22 | 2015-04-20 17:18:15 -0700 | [diff] [blame] | 301 | public void onAppPicked(ResolveInfo info) { |
| 302 | final Intent intent = new Intent(getIntent()); |
| 303 | intent.setFlags(intent.getFlags() & ~Intent.FLAG_ACTIVITY_FORWARD_RESULT); |
| 304 | intent.setComponent(new ComponentName( |
| 305 | info.activityInfo.applicationInfo.packageName, info.activityInfo.name)); |
| 306 | startActivityForResult(intent, CODE_FORWARD); |
| 307 | } |
Jeff Sharkey | 38ec252 | 2013-09-24 12:07:12 -0700 | [diff] [blame] | 308 | |
Steve McKay | b68dd22 | 2015-04-20 17:18:15 -0700 | [diff] [blame] | 309 | @Override |
| 310 | protected void onActivityResult(int requestCode, int resultCode, Intent data) { |
| 311 | Log.d(TAG, "onActivityResult() code=" + resultCode); |
Jeff Sharkey | 38ec252 | 2013-09-24 12:07:12 -0700 | [diff] [blame] | 312 | |
Steve McKay | b68dd22 | 2015-04-20 17:18:15 -0700 | [diff] [blame] | 313 | // Only relay back results when not canceled; otherwise stick around to |
| 314 | // let the user pick another app/backend. |
| 315 | if (requestCode == CODE_FORWARD && resultCode != RESULT_CANCELED) { |
Jeff Sharkey | 8b99704 | 2013-09-19 15:25:56 -0700 | [diff] [blame] | 316 | |
Steve McKay | b68dd22 | 2015-04-20 17:18:15 -0700 | [diff] [blame] | 317 | // Remember that we last picked via external app |
| 318 | final String packageName = getCallingPackageMaybeExtra(); |
| 319 | final ContentValues values = new ContentValues(); |
| 320 | values.put(ResumeColumns.EXTERNAL, 1); |
| 321 | getContentResolver().insert(RecentsProvider.buildResume(packageName), values); |
| 322 | |
| 323 | // Pass back result to original caller |
| 324 | setResult(resultCode, data); |
| 325 | finish(); |
| 326 | } else { |
| 327 | super.onActivityResult(requestCode, resultCode, data); |
Jeff Sharkey | f339f25 | 2013-08-15 16:17:41 -0700 | [diff] [blame] | 328 | } |
| 329 | } |
| 330 | |
Jeff Sharkey | 46165b5 | 2013-07-31 20:53:22 -0700 | [diff] [blame] | 331 | private DrawerListener mDrawerListener = new DrawerListener() { |
| 332 | @Override |
| 333 | public void onDrawerSlide(View drawerView, float slideOffset) { |
| 334 | mDrawerToggle.onDrawerSlide(drawerView, slideOffset); |
| 335 | } |
| 336 | |
| 337 | @Override |
| 338 | public void onDrawerOpened(View drawerView) { |
| 339 | mDrawerToggle.onDrawerOpened(drawerView); |
Jeff Sharkey | 46165b5 | 2013-07-31 20:53:22 -0700 | [diff] [blame] | 340 | } |
| 341 | |
| 342 | @Override |
| 343 | public void onDrawerClosed(View drawerView) { |
| 344 | mDrawerToggle.onDrawerClosed(drawerView); |
Jeff Sharkey | 46165b5 | 2013-07-31 20:53:22 -0700 | [diff] [blame] | 345 | } |
| 346 | |
| 347 | @Override |
| 348 | public void onDrawerStateChanged(int newState) { |
| 349 | mDrawerToggle.onDrawerStateChanged(newState); |
| 350 | } |
| 351 | }; |
| 352 | |
| 353 | @Override |
| 354 | protected void onPostCreate(Bundle savedInstanceState) { |
| 355 | super.onPostCreate(savedInstanceState); |
Jeff Sharkey | 7d58fc6 | 2013-09-12 16:25:02 -0700 | [diff] [blame] | 356 | if (mDrawerToggle != null) { |
| 357 | mDrawerToggle.syncState(); |
| 358 | } |
Jeff Sharkey | b58b3d3 | 2014-11-24 10:00:00 -0800 | [diff] [blame] | 359 | updateActionBar(); |
Jeff Sharkey | 7d58fc6 | 2013-09-12 16:25:02 -0700 | [diff] [blame] | 360 | } |
| 361 | |
| 362 | public void setRootsDrawerOpen(boolean open) { |
| 363 | if (!mShowAsDialog) { |
| 364 | if (open) { |
Jeff Sharkey | e6fcceb | 2014-07-28 16:38:52 -0700 | [diff] [blame] | 365 | mDrawerLayout.openDrawer(mRootsDrawer); |
Jeff Sharkey | 7d58fc6 | 2013-09-12 16:25:02 -0700 | [diff] [blame] | 366 | } else { |
Jeff Sharkey | e6fcceb | 2014-07-28 16:38:52 -0700 | [diff] [blame] | 367 | mDrawerLayout.closeDrawer(mRootsDrawer); |
Jeff Sharkey | 7d58fc6 | 2013-09-12 16:25:02 -0700 | [diff] [blame] | 368 | } |
| 369 | } |
| 370 | } |
| 371 | |
| 372 | private boolean isRootsDrawerOpen() { |
| 373 | if (mShowAsDialog) { |
| 374 | return false; |
| 375 | } else { |
Jeff Sharkey | e6fcceb | 2014-07-28 16:38:52 -0700 | [diff] [blame] | 376 | return mDrawerLayout.isDrawerOpen(mRootsDrawer); |
Jeff Sharkey | 7d58fc6 | 2013-09-12 16:25:02 -0700 | [diff] [blame] | 377 | } |
Jeff Sharkey | e22d02e | 2013-04-26 16:54:55 -0700 | [diff] [blame] | 378 | } |
| 379 | |
Steve McKay | b68dd22 | 2015-04-20 17:18:15 -0700 | [diff] [blame] | 380 | @Override |
Jeff Sharkey | 09c10bf | 2013-06-30 20:02:59 -0700 | [diff] [blame] | 381 | public void updateActionBar() { |
Jeff Sharkey | e6fcceb | 2014-07-28 16:38:52 -0700 | [diff] [blame] | 382 | if (mRootsToolbar != null) { |
Daichi Hirono | caadd41 | 2015-04-10 15:50:38 +0900 | [diff] [blame] | 383 | if (mState.action == ACTION_OPEN || |
| 384 | mState.action == ACTION_GET_CONTENT || |
| 385 | mState.action == ACTION_OPEN_TREE) { |
Jeff Sharkey | e6fcceb | 2014-07-28 16:38:52 -0700 | [diff] [blame] | 386 | mRootsToolbar.setTitle(R.string.title_open); |
Daichi Hirono | caadd41 | 2015-04-10 15:50:38 +0900 | [diff] [blame] | 387 | } else if (mState.action == ACTION_CREATE || |
| 388 | mState.action == ACTION_OPEN_COPY_DESTINATION) { |
Jeff Sharkey | e6fcceb | 2014-07-28 16:38:52 -0700 | [diff] [blame] | 389 | mRootsToolbar.setTitle(R.string.title_save); |
Jeff Sharkey | 09c10bf | 2013-06-30 20:02:59 -0700 | [diff] [blame] | 390 | } |
Jeff Sharkey | e6fcceb | 2014-07-28 16:38:52 -0700 | [diff] [blame] | 391 | } |
Jeff Sharkey | a5defe3 | 2013-08-05 17:56:48 -0700 | [diff] [blame] | 392 | |
Jeff Sharkey | e6fcceb | 2014-07-28 16:38:52 -0700 | [diff] [blame] | 393 | final RootInfo root = getCurrentRoot(); |
Jeff Sharkey | 311a7d8 | 2015-04-11 21:27:21 -0700 | [diff] [blame] | 394 | final boolean showRootIcon = mShowAsDialog |
| 395 | || (mState.action == ACTION_MANAGE || mState.action == ACTION_BROWSE); |
Jeff Sharkey | e6fcceb | 2014-07-28 16:38:52 -0700 | [diff] [blame] | 396 | if (showRootIcon) { |
Jeff Sharkey | 34c5409 | 2014-08-08 13:08:56 -0700 | [diff] [blame] | 397 | mToolbar.setNavigationIcon( |
| 398 | root != null ? root.loadToolbarIcon(mToolbar.getContext()) : null); |
Jeff Sharkey | 738d8a5 | 2014-10-13 12:53:13 -0700 | [diff] [blame] | 399 | mToolbar.setNavigationContentDescription(R.string.drawer_open); |
Jeff Sharkey | e6fcceb | 2014-07-28 16:38:52 -0700 | [diff] [blame] | 400 | mToolbar.setNavigationOnClickListener(null); |
| 401 | } else { |
| 402 | mToolbar.setNavigationIcon(R.drawable.ic_hamburger); |
Jeff Sharkey | 738d8a5 | 2014-10-13 12:53:13 -0700 | [diff] [blame] | 403 | mToolbar.setNavigationContentDescription(R.string.drawer_open); |
Jeff Sharkey | e6fcceb | 2014-07-28 16:38:52 -0700 | [diff] [blame] | 404 | mToolbar.setNavigationOnClickListener(new View.OnClickListener() { |
| 405 | @Override |
| 406 | public void onClick(View v) { |
| 407 | setRootsDrawerOpen(true); |
| 408 | } |
| 409 | }); |
| 410 | } |
| 411 | |
Steve McKay | b68dd22 | 2015-04-20 17:18:15 -0700 | [diff] [blame] | 412 | if (mSearchManager.isExpanded()) { |
Jeff Sharkey | e6fcceb | 2014-07-28 16:38:52 -0700 | [diff] [blame] | 413 | mToolbar.setTitle(null); |
| 414 | mToolbarStack.setVisibility(View.GONE); |
| 415 | mToolbarStack.setAdapter(null); |
| 416 | } else { |
Jeff Sharkey | 4c5fe52 | 2013-09-03 14:17:06 -0700 | [diff] [blame] | 417 | if (mState.stack.size() <= 1) { |
Jeff Sharkey | e6fcceb | 2014-07-28 16:38:52 -0700 | [diff] [blame] | 418 | mToolbar.setTitle(root.title); |
| 419 | mToolbarStack.setVisibility(View.GONE); |
| 420 | mToolbarStack.setAdapter(null); |
Jeff Sharkey | a5defe3 | 2013-08-05 17:56:48 -0700 | [diff] [blame] | 421 | } else { |
Jeff Sharkey | e6fcceb | 2014-07-28 16:38:52 -0700 | [diff] [blame] | 422 | mToolbar.setTitle(null); |
| 423 | mToolbarStack.setVisibility(View.VISIBLE); |
| 424 | mToolbarStack.setAdapter(mStackAdapter); |
| 425 | |
Steve McKay | b68dd22 | 2015-04-20 17:18:15 -0700 | [diff] [blame] | 426 | mStackListener.mIgnoreNextNavigation = true; |
Jeff Sharkey | e6fcceb | 2014-07-28 16:38:52 -0700 | [diff] [blame] | 427 | mToolbarStack.setSelection(mStackAdapter.getCount() - 1); |
Jeff Sharkey | 46165b5 | 2013-07-31 20:53:22 -0700 | [diff] [blame] | 428 | } |
Jeff Sharkey | 09c10bf | 2013-06-30 20:02:59 -0700 | [diff] [blame] | 429 | } |
| 430 | } |
| 431 | |
| 432 | @Override |
| 433 | public boolean onCreateOptionsMenu(Menu menu) { |
Steve McKay | b68dd22 | 2015-04-20 17:18:15 -0700 | [diff] [blame] | 434 | boolean showMenu = super.onCreateOptionsMenu(menu); |
| 435 | |
Jeff Sharkey | e8d13ea | 2014-08-08 15:10:03 -0700 | [diff] [blame] | 436 | // Most actions are visible when showing as dialog |
Jeff Sharkey | 7d58fc6 | 2013-09-12 16:25:02 -0700 | [diff] [blame] | 437 | if (mShowAsDialog) { |
Steve McKay | b68dd22 | 2015-04-20 17:18:15 -0700 | [diff] [blame] | 438 | expandMenus(menu); |
Jeff Sharkey | 7d58fc6 | 2013-09-12 16:25:02 -0700 | [diff] [blame] | 439 | } |
Steve McKay | b68dd22 | 2015-04-20 17:18:15 -0700 | [diff] [blame] | 440 | return showMenu; |
Jeff Sharkey | 09c10bf | 2013-06-30 20:02:59 -0700 | [diff] [blame] | 441 | } |
| 442 | |
| 443 | @Override |
| 444 | public boolean onPrepareOptionsMenu(Menu menu) { |
| 445 | super.onPrepareOptionsMenu(menu); |
| 446 | |
Jeff Sharkey | 0e8c871 | 2013-09-12 21:59:06 -0700 | [diff] [blame] | 447 | final RootInfo root = getCurrentRoot(); |
Jeff Sharkey | 724deeb | 2013-08-31 15:02:20 -0700 | [diff] [blame] | 448 | final DocumentInfo cwd = getCurrentDirectory(); |
Jeff Sharkey | 5b53592 | 2013-08-02 15:55:26 -0700 | [diff] [blame] | 449 | |
Jeff Sharkey | 09c10bf | 2013-06-30 20:02:59 -0700 | [diff] [blame] | 450 | final MenuItem createDir = menu.findItem(R.id.menu_create_dir); |
Jeff Sharkey | 4c5fe52 | 2013-09-03 14:17:06 -0700 | [diff] [blame] | 451 | final MenuItem grid = menu.findItem(R.id.menu_grid); |
Jeff Sharkey | c6cbdf1 | 2013-08-07 16:22:02 -0700 | [diff] [blame] | 452 | final MenuItem list = menu.findItem(R.id.menu_list); |
Jeff Sharkey | e8d13ea | 2014-08-08 15:10:03 -0700 | [diff] [blame] | 453 | final MenuItem advanced = menu.findItem(R.id.menu_advanced); |
| 454 | final MenuItem fileSize = menu.findItem(R.id.menu_file_size); |
Jeff Sharkey | 938528d | 2015-04-12 21:52:24 -0700 | [diff] [blame] | 455 | final MenuItem settings = menu.findItem(R.id.menu_settings); |
Jeff Sharkey | 5b53592 | 2013-08-02 15:55:26 -0700 | [diff] [blame] | 456 | |
Jeff Sharkey | 311a7d8 | 2015-04-11 21:27:21 -0700 | [diff] [blame] | 457 | boolean fileSizeVisible = !(mState.action == ACTION_MANAGE |
| 458 | || mState.action == ACTION_BROWSE); |
Jeff Sharkey | f4943e1 | 2014-06-04 16:42:47 -0700 | [diff] [blame] | 459 | if (mState.action == ACTION_CREATE || mState.action == ACTION_OPEN_TREE) { |
Jeff Sharkey | c6cbdf1 | 2013-08-07 16:22:02 -0700 | [diff] [blame] | 460 | createDir.setVisible(cwd != null && cwd.isCreateSupported()); |
Steve McKay | b68dd22 | 2015-04-20 17:18:15 -0700 | [diff] [blame] | 461 | mSearchManager.showMenu(false); |
Jeff Sharkey | c6cbdf1 | 2013-08-07 16:22:02 -0700 | [diff] [blame] | 462 | |
| 463 | // No display options in recent directories |
| 464 | if (cwd == null) { |
| 465 | grid.setVisible(false); |
| 466 | list.setVisible(false); |
Jeff Sharkey | 524811c | 2014-10-23 13:59:54 -0700 | [diff] [blame] | 467 | fileSizeVisible = false; |
Jeff Sharkey | c6cbdf1 | 2013-08-07 16:22:02 -0700 | [diff] [blame] | 468 | } |
| 469 | |
Jeff Sharkey | 6e565ff | 2014-04-05 19:05:24 -0700 | [diff] [blame] | 470 | if (mState.action == ACTION_CREATE) { |
Steve McKay | 7bd32e1 | 2015-04-30 16:12:59 -0700 | [diff] [blame] | 471 | final FragmentManager fm = getFragmentManager(); |
Jeff Sharkey | 6e565ff | 2014-04-05 19:05:24 -0700 | [diff] [blame] | 472 | SaveFragment.get(fm).setSaveEnabled(cwd != null && cwd.isCreateSupported()); |
| 473 | } |
Jeff Sharkey | c6cbdf1 | 2013-08-07 16:22:02 -0700 | [diff] [blame] | 474 | } else { |
| 475 | createDir.setVisible(false); |
Jeff Sharkey | 5b53592 | 2013-08-02 15:55:26 -0700 | [diff] [blame] | 476 | } |
Jeff Sharkey | 46165b5 | 2013-07-31 20:53:22 -0700 | [diff] [blame] | 477 | |
Jeff Sharkey | 311a7d8 | 2015-04-11 21:27:21 -0700 | [diff] [blame] | 478 | advanced.setVisible(!(mState.action == ACTION_MANAGE || mState.action == ACTION_BROWSE)); |
Jeff Sharkey | 524811c | 2014-10-23 13:59:54 -0700 | [diff] [blame] | 479 | fileSize.setVisible(fileSizeVisible); |
Jeff Sharkey | f339f25 | 2013-08-15 16:17:41 -0700 | [diff] [blame] | 480 | |
Jeff Sharkey | 938528d | 2015-04-12 21:52:24 -0700 | [diff] [blame] | 481 | settings.setVisible((mState.action == ACTION_MANAGE || mState.action == ACTION_BROWSE) |
| 482 | && (root.flags & Root.FLAG_HAS_SETTINGS) != 0); |
| 483 | |
Jeff Sharkey | 09c10bf | 2013-06-30 20:02:59 -0700 | [diff] [blame] | 484 | return true; |
| 485 | } |
| 486 | |
| 487 | @Override |
| 488 | public boolean onOptionsItemSelected(MenuItem item) { |
Jeff Sharkey | 7d58fc6 | 2013-09-12 16:25:02 -0700 | [diff] [blame] | 489 | if (mDrawerToggle != null && mDrawerToggle.onOptionsItemSelected(item)) { |
Jeff Sharkey | 46165b5 | 2013-07-31 20:53:22 -0700 | [diff] [blame] | 490 | return true; |
| 491 | } |
Steve McKay | b68dd22 | 2015-04-20 17:18:15 -0700 | [diff] [blame] | 492 | return super.onOptionsItemSelected(item); |
Jeff Sharkey | 4be51f1 | 2013-10-23 15:46:38 -0700 | [diff] [blame] | 493 | } |
| 494 | |
Jeff Sharkey | 5b53592 | 2013-08-02 15:55:26 -0700 | [diff] [blame] | 495 | @Override |
| 496 | public void onBackPressed() { |
Jeff Sharkey | d10f049 | 2013-09-09 17:35:46 -0700 | [diff] [blame] | 497 | if (!mState.stackTouched) { |
| 498 | super.onBackPressed(); |
| 499 | return; |
| 500 | } |
| 501 | |
Jeff Sharkey | b362044 | 2013-09-01 18:41:04 -0700 | [diff] [blame] | 502 | final int size = mState.stack.size(); |
Jeff Sharkey | 5b53592 | 2013-08-02 15:55:26 -0700 | [diff] [blame] | 503 | if (size > 1) { |
Jeff Sharkey | b362044 | 2013-09-01 18:41:04 -0700 | [diff] [blame] | 504 | mState.stack.pop(); |
Jeff Sharkey | c8ae7a5 | 2013-09-18 16:26:49 -0700 | [diff] [blame] | 505 | onCurrentDirectoryChanged(ANIM_UP); |
Jeff Sharkey | 7d58fc6 | 2013-09-12 16:25:02 -0700 | [diff] [blame] | 506 | } else if (size == 1 && !isRootsDrawerOpen()) { |
Jeff Sharkey | 5b53592 | 2013-08-02 15:55:26 -0700 | [diff] [blame] | 507 | // TODO: open root drawer once we can capture back key |
| 508 | super.onBackPressed(); |
| 509 | } else { |
| 510 | super.onBackPressed(); |
Jeff Sharkey | 09c10bf | 2013-06-30 20:02:59 -0700 | [diff] [blame] | 511 | } |
Jeff Sharkey | 5b53592 | 2013-08-02 15:55:26 -0700 | [diff] [blame] | 512 | } |
Jeff Sharkey | 09c10bf | 2013-06-30 20:02:59 -0700 | [diff] [blame] | 513 | |
Jeff Sharkey | b362044 | 2013-09-01 18:41:04 -0700 | [diff] [blame] | 514 | @Override |
Jeff Sharkey | b362044 | 2013-09-01 18:41:04 -0700 | [diff] [blame] | 515 | public State getDisplayState() { |
| 516 | return mState; |
Jeff Sharkey | 3c28b79 | 2013-07-01 17:22:02 -0700 | [diff] [blame] | 517 | } |
| 518 | |
Steve McKay | b68dd22 | 2015-04-20 17:18:15 -0700 | [diff] [blame] | 519 | @Override |
| 520 | void onDirectoryChanged(int anim) { |
Jeff Sharkey | 5b53592 | 2013-08-02 15:55:26 -0700 | [diff] [blame] | 521 | final FragmentManager fm = getFragmentManager(); |
Jeff Sharkey | a4d1f22 | 2013-09-07 14:45:03 -0700 | [diff] [blame] | 522 | final RootInfo root = getCurrentRoot(); |
Jeff Sharkey | 724deeb | 2013-08-31 15:02:20 -0700 | [diff] [blame] | 523 | final DocumentInfo cwd = getCurrentDirectory(); |
Jeff Sharkey | c6cbdf1 | 2013-08-07 16:22:02 -0700 | [diff] [blame] | 524 | |
Jeff Sharkey | c8ae7a5 | 2013-09-18 16:26:49 -0700 | [diff] [blame] | 525 | mDirectoryContainer.setDrawDisappearingFirst(anim == ANIM_DOWN); |
| 526 | |
Jeff Sharkey | 2e694f8 | 2013-08-06 16:26:14 -0700 | [diff] [blame] | 527 | if (cwd == null) { |
| 528 | // No directory means recents |
Daichi Hirono | caadd41 | 2015-04-10 15:50:38 +0900 | [diff] [blame] | 529 | if (mState.action == ACTION_CREATE || |
| 530 | mState.action == ACTION_OPEN_TREE || |
| 531 | mState.action == ACTION_OPEN_COPY_DESTINATION) { |
Jeff Sharkey | 2e694f8 | 2013-08-06 16:26:14 -0700 | [diff] [blame] | 532 | RecentsCreateFragment.show(fm); |
| 533 | } else { |
Jeff Sharkey | c8ae7a5 | 2013-09-18 16:26:49 -0700 | [diff] [blame] | 534 | DirectoryFragment.showRecentsOpen(fm, anim); |
Jeff Sharkey | 7d58fc6 | 2013-09-12 16:25:02 -0700 | [diff] [blame] | 535 | |
Jeff Sharkey | 38ec252 | 2013-09-24 12:07:12 -0700 | [diff] [blame] | 536 | // Start recents in grid when requesting visual things |
| 537 | final boolean visualMimes = MimePredicate.mimeMatches( |
| 538 | MimePredicate.VISUAL_MIMES, mState.acceptMimes); |
Steve McKay | b68dd22 | 2015-04-20 17:18:15 -0700 | [diff] [blame] | 539 | mState.userMode = visualMimes ? State.MODE_GRID : State.MODE_LIST; |
Jeff Sharkey | 7d58fc6 | 2013-09-12 16:25:02 -0700 | [diff] [blame] | 540 | mState.derivedMode = mState.userMode; |
Jeff Sharkey | 2e694f8 | 2013-08-06 16:26:14 -0700 | [diff] [blame] | 541 | } |
| 542 | } else { |
Jeff Sharkey | b362044 | 2013-09-01 18:41:04 -0700 | [diff] [blame] | 543 | if (mState.currentSearch != null) { |
Jeff Sharkey | 2e694f8 | 2013-08-06 16:26:14 -0700 | [diff] [blame] | 544 | // Ongoing search |
Jeff Sharkey | c8ae7a5 | 2013-09-18 16:26:49 -0700 | [diff] [blame] | 545 | DirectoryFragment.showSearch(fm, root, mState.currentSearch, anim); |
Jeff Sharkey | 2e694f8 | 2013-08-06 16:26:14 -0700 | [diff] [blame] | 546 | } else { |
| 547 | // Normal boring directory |
Jeff Sharkey | c8ae7a5 | 2013-09-18 16:26:49 -0700 | [diff] [blame] | 548 | DirectoryFragment.showNormal(fm, root, cwd, anim); |
Jeff Sharkey | 2e694f8 | 2013-08-06 16:26:14 -0700 | [diff] [blame] | 549 | } |
Jeff Sharkey | 09c10bf | 2013-06-30 20:02:59 -0700 | [diff] [blame] | 550 | } |
Jeff Sharkey | 2e694f8 | 2013-08-06 16:26:14 -0700 | [diff] [blame] | 551 | |
Jeff Sharkey | c6cbdf1 | 2013-08-07 16:22:02 -0700 | [diff] [blame] | 552 | // Forget any replacement target |
Jeff Sharkey | b362044 | 2013-09-01 18:41:04 -0700 | [diff] [blame] | 553 | if (mState.action == ACTION_CREATE) { |
Jeff Sharkey | c6cbdf1 | 2013-08-07 16:22:02 -0700 | [diff] [blame] | 554 | final SaveFragment save = SaveFragment.get(fm); |
| 555 | if (save != null) { |
| 556 | save.setReplaceTarget(null); |
| 557 | } |
| 558 | } |
| 559 | |
Daichi Hirono | caadd41 | 2015-04-10 15:50:38 +0900 | [diff] [blame] | 560 | if (mState.action == ACTION_OPEN_TREE || |
| 561 | mState.action == ACTION_OPEN_COPY_DESTINATION) { |
Jeff Sharkey | 6e565ff | 2014-04-05 19:05:24 -0700 | [diff] [blame] | 562 | final PickFragment pick = PickFragment.get(fm); |
| 563 | if (pick != null) { |
| 564 | final CharSequence displayName = (mState.stack.size() <= 1) ? root.title |
| 565 | : cwd.displayName; |
Daichi Hirono | 676453c | 2015-04-14 12:16:59 +0900 | [diff] [blame] | 566 | pick.setPickTarget(mState.action, cwd, displayName); |
Jeff Sharkey | 6e565ff | 2014-04-05 19:05:24 -0700 | [diff] [blame] | 567 | } |
| 568 | } |
Steve McKay | b68dd22 | 2015-04-20 17:18:15 -0700 | [diff] [blame] | 569 | } |
Jeff Sharkey | 6e565ff | 2014-04-05 19:05:24 -0700 | [diff] [blame] | 570 | |
Steve McKay | b68dd22 | 2015-04-20 17:18:15 -0700 | [diff] [blame] | 571 | void onSaveRequested(DocumentInfo replaceTarget) { |
| 572 | new ExistingFinishTask(replaceTarget.derivedUri).executeOnExecutor(getCurrentExecutor()); |
| 573 | } |
Jeff Sharkey | 42d2679 | 2013-09-06 13:22:09 -0700 | [diff] [blame] | 574 | |
Steve McKay | b68dd22 | 2015-04-20 17:18:15 -0700 | [diff] [blame] | 575 | void onSaveRequested(String mimeType, String displayName) { |
| 576 | new CreateFinishTask(mimeType, displayName).executeOnExecutor(getCurrentExecutor()); |
Jeff Sharkey | 09c10bf | 2013-06-30 20:02:59 -0700 | [diff] [blame] | 577 | } |
| 578 | |
Steve McKay | d0a2a2c | 2015-03-25 14:35:33 -0700 | [diff] [blame] | 579 | @Override |
Steve McKay | b68dd22 | 2015-04-20 17:18:15 -0700 | [diff] [blame] | 580 | void onRootPicked(RootInfo root) { |
| 581 | super.onRootPicked(root); |
| 582 | setRootsDrawerOpen(false); |
Jeff Sharkey | 1d890e0 | 2013-08-15 11:24:03 -0700 | [diff] [blame] | 583 | } |
| 584 | |
Steve McKay | d0a2a2c | 2015-03-25 14:35:33 -0700 | [diff] [blame] | 585 | @Override |
Jeff Sharkey | 724deeb | 2013-08-31 15:02:20 -0700 | [diff] [blame] | 586 | public void onDocumentPicked(DocumentInfo doc) { |
Jeff Sharkey | 09c10bf | 2013-06-30 20:02:59 -0700 | [diff] [blame] | 587 | final FragmentManager fm = getFragmentManager(); |
Jeff Sharkey | 2e694f8 | 2013-08-06 16:26:14 -0700 | [diff] [blame] | 588 | if (doc.isDirectory()) { |
Jeff Sharkey | b362044 | 2013-09-01 18:41:04 -0700 | [diff] [blame] | 589 | mState.stack.push(doc); |
Jeff Sharkey | d10f049 | 2013-09-09 17:35:46 -0700 | [diff] [blame] | 590 | mState.stackTouched = true; |
Jeff Sharkey | c8ae7a5 | 2013-09-18 16:26:49 -0700 | [diff] [blame] | 591 | onCurrentDirectoryChanged(ANIM_DOWN); |
Jeff Sharkey | b362044 | 2013-09-01 18:41:04 -0700 | [diff] [blame] | 592 | } else if (mState.action == ACTION_OPEN || mState.action == ACTION_GET_CONTENT) { |
Jeff Sharkey | 09c10bf | 2013-06-30 20:02:59 -0700 | [diff] [blame] | 593 | // Explicit file picked, return |
Jeff Sharkey | f63b777 | 2013-10-01 17:57:41 -0700 | [diff] [blame] | 594 | new ExistingFinishTask(doc.derivedUri).executeOnExecutor(getCurrentExecutor()); |
Jeff Sharkey | b362044 | 2013-09-01 18:41:04 -0700 | [diff] [blame] | 595 | } else if (mState.action == ACTION_CREATE) { |
Jeff Sharkey | c6cbdf1 | 2013-08-07 16:22:02 -0700 | [diff] [blame] | 596 | // Replace selected file |
| 597 | SaveFragment.get(fm).setReplaceTarget(doc); |
Jeff Sharkey | b362044 | 2013-09-01 18:41:04 -0700 | [diff] [blame] | 598 | } else if (mState.action == ACTION_MANAGE) { |
Jeff Sharkey | 91a101c | 2013-09-05 17:14:14 -0700 | [diff] [blame] | 599 | // First try managing the document; we expect manager to filter |
| 600 | // based on authority, so we don't grant. |
| 601 | final Intent manage = new Intent(DocumentsContract.ACTION_MANAGE_DOCUMENT); |
Jeff Sharkey | a4d1f22 | 2013-09-07 14:45:03 -0700 | [diff] [blame] | 602 | manage.setData(doc.derivedUri); |
Jeff Sharkey | 91a101c | 2013-09-05 17:14:14 -0700 | [diff] [blame] | 603 | |
Jeff Sharkey | 873daa3 | 2013-08-18 17:38:20 -0700 | [diff] [blame] | 604 | try { |
Jeff Sharkey | 91a101c | 2013-09-05 17:14:14 -0700 | [diff] [blame] | 605 | startActivity(manage); |
Jeff Sharkey | 873daa3 | 2013-08-18 17:38:20 -0700 | [diff] [blame] | 606 | } catch (ActivityNotFoundException ex) { |
Jeff Sharkey | 91a101c | 2013-09-05 17:14:14 -0700 | [diff] [blame] | 607 | // Fall back to viewing |
| 608 | final Intent view = new Intent(Intent.ACTION_VIEW); |
| 609 | view.setFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION); |
Jeff Sharkey | a4d1f22 | 2013-09-07 14:45:03 -0700 | [diff] [blame] | 610 | view.setData(doc.derivedUri); |
Jeff Sharkey | 91a101c | 2013-09-05 17:14:14 -0700 | [diff] [blame] | 611 | |
| 612 | try { |
| 613 | startActivity(view); |
| 614 | } catch (ActivityNotFoundException ex2) { |
| 615 | Toast.makeText(this, R.string.toast_no_application, Toast.LENGTH_SHORT).show(); |
| 616 | } |
Jeff Sharkey | 873daa3 | 2013-08-18 17:38:20 -0700 | [diff] [blame] | 617 | } |
Jeff Sharkey | 311a7d8 | 2015-04-11 21:27:21 -0700 | [diff] [blame] | 618 | } else if (mState.action == ACTION_BROWSE) { |
| 619 | // Go straight to viewing |
| 620 | final Intent view = new Intent(Intent.ACTION_VIEW); |
| 621 | view.setFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION); |
| 622 | view.setData(doc.derivedUri); |
| 623 | |
| 624 | try { |
| 625 | startActivity(view); |
| 626 | } catch (ActivityNotFoundException ex) { |
| 627 | Toast.makeText(this, R.string.toast_no_application, Toast.LENGTH_SHORT).show(); |
| 628 | } |
Jeff Sharkey | 09c10bf | 2013-06-30 20:02:59 -0700 | [diff] [blame] | 629 | } |
| 630 | } |
| 631 | |
Steve McKay | d0a2a2c | 2015-03-25 14:35:33 -0700 | [diff] [blame] | 632 | @Override |
Jeff Sharkey | 724deeb | 2013-08-31 15:02:20 -0700 | [diff] [blame] | 633 | public void onDocumentsPicked(List<DocumentInfo> docs) { |
Jeff Sharkey | b362044 | 2013-09-01 18:41:04 -0700 | [diff] [blame] | 634 | if (mState.action == ACTION_OPEN || mState.action == ACTION_GET_CONTENT) { |
Jeff Sharkey | 873daa3 | 2013-08-18 17:38:20 -0700 | [diff] [blame] | 635 | final int size = docs.size(); |
| 636 | final Uri[] uris = new Uri[size]; |
| 637 | for (int i = 0; i < size; i++) { |
Jeff Sharkey | a4d1f22 | 2013-09-07 14:45:03 -0700 | [diff] [blame] | 638 | uris[i] = docs.get(i).derivedUri; |
Jeff Sharkey | 873daa3 | 2013-08-18 17:38:20 -0700 | [diff] [blame] | 639 | } |
Jeff Sharkey | f63b777 | 2013-10-01 17:57:41 -0700 | [diff] [blame] | 640 | new ExistingFinishTask(uris).executeOnExecutor(getCurrentExecutor()); |
Jeff Sharkey | c317af8 | 2013-07-01 16:56:54 -0700 | [diff] [blame] | 641 | } |
Jeff Sharkey | 09c10bf | 2013-06-30 20:02:59 -0700 | [diff] [blame] | 642 | } |
| 643 | |
Jeff Sharkey | 6e565ff | 2014-04-05 19:05:24 -0700 | [diff] [blame] | 644 | public void onPickRequested(DocumentInfo pickTarget) { |
Daichi Hirono | caadd41 | 2015-04-10 15:50:38 +0900 | [diff] [blame] | 645 | Uri result; |
| 646 | if (mState.action == ACTION_OPEN_TREE) { |
| 647 | result = DocumentsContract.buildTreeDocumentUri( |
| 648 | pickTarget.authority, pickTarget.documentId); |
| 649 | } else if (mState.action == ACTION_OPEN_COPY_DESTINATION) { |
| 650 | result = pickTarget.derivedUri; |
| 651 | } else { |
| 652 | // Should not be reached. |
| 653 | throw new IllegalStateException("Invalid mState.action."); |
| 654 | } |
| 655 | new PickFinishTask(result).executeOnExecutor(getCurrentExecutor()); |
Jeff Sharkey | 6e565ff | 2014-04-05 19:05:24 -0700 | [diff] [blame] | 656 | } |
| 657 | |
Steve McKay | b68dd22 | 2015-04-20 17:18:15 -0700 | [diff] [blame] | 658 | @Override |
| 659 | void saveStackBlocking() { |
Jeff Sharkey | 5b53592 | 2013-08-02 15:55:26 -0700 | [diff] [blame] | 660 | final ContentResolver resolver = getContentResolver(); |
| 661 | final ContentValues values = new ContentValues(); |
| 662 | |
Jeff Sharkey | b362044 | 2013-09-01 18:41:04 -0700 | [diff] [blame] | 663 | final byte[] rawStack = DurableUtils.writeToArrayOrNull(mState.stack); |
Daichi Hirono | caadd41 | 2015-04-10 15:50:38 +0900 | [diff] [blame] | 664 | if (mState.action == ACTION_CREATE || |
| 665 | mState.action == ACTION_OPEN_TREE || |
| 666 | mState.action == ACTION_OPEN_COPY_DESTINATION) { |
Jeff Sharkey | 5b53592 | 2013-08-02 15:55:26 -0700 | [diff] [blame] | 667 | // Remember stack for last create |
| 668 | values.clear(); |
Jeff Sharkey | 9dd0262 | 2013-09-27 16:44:11 -0700 | [diff] [blame] | 669 | values.put(RecentColumns.KEY, mState.stack.buildKey()); |
Jeff Sharkey | a4d1f22 | 2013-09-07 14:45:03 -0700 | [diff] [blame] | 670 | values.put(RecentColumns.STACK, rawStack); |
| 671 | resolver.insert(RecentsProvider.buildRecent(), values); |
Jeff Sharkey | 5b53592 | 2013-08-02 15:55:26 -0700 | [diff] [blame] | 672 | } |
| 673 | |
| 674 | // Remember location for next app launch |
Jeff Sharkey | 0b744d8 | 2013-10-09 13:52:17 -0700 | [diff] [blame] | 675 | final String packageName = getCallingPackageMaybeExtra(); |
Jeff Sharkey | 5b53592 | 2013-08-02 15:55:26 -0700 | [diff] [blame] | 676 | values.clear(); |
Jeff Sharkey | a4d1f22 | 2013-09-07 14:45:03 -0700 | [diff] [blame] | 677 | values.put(ResumeColumns.STACK, rawStack); |
Jeff Sharkey | 38ec252 | 2013-09-24 12:07:12 -0700 | [diff] [blame] | 678 | values.put(ResumeColumns.EXTERNAL, 0); |
Jeff Sharkey | 5b53592 | 2013-08-02 15:55:26 -0700 | [diff] [blame] | 679 | resolver.insert(RecentsProvider.buildResume(packageName), values); |
Jeff Sharkey | 9dd0262 | 2013-09-27 16:44:11 -0700 | [diff] [blame] | 680 | } |
| 681 | |
Steve McKay | b68dd22 | 2015-04-20 17:18:15 -0700 | [diff] [blame] | 682 | @Override |
| 683 | void onTaskFinished(Uri... uris) { |
Jeff Sharkey | 9dd0262 | 2013-09-27 16:44:11 -0700 | [diff] [blame] | 684 | Log.d(TAG, "onFinished() " + Arrays.toString(uris)); |
Jeff Sharkey | 5b53592 | 2013-08-02 15:55:26 -0700 | [diff] [blame] | 685 | |
Jeff Sharkey | e22d02e | 2013-04-26 16:54:55 -0700 | [diff] [blame] | 686 | final Intent intent = new Intent(); |
Jeff Sharkey | c317af8 | 2013-07-01 16:56:54 -0700 | [diff] [blame] | 687 | if (uris.length == 1) { |
| 688 | intent.setData(uris[0]); |
| 689 | } else if (uris.length > 1) { |
Jeff Sharkey | a5defe3 | 2013-08-05 17:56:48 -0700 | [diff] [blame] | 690 | final ClipData clipData = new ClipData( |
Jeff Sharkey | b362044 | 2013-09-01 18:41:04 -0700 | [diff] [blame] | 691 | null, mState.acceptMimes, new ClipData.Item(uris[0])); |
Jeff Sharkey | c317af8 | 2013-07-01 16:56:54 -0700 | [diff] [blame] | 692 | for (int i = 1; i < uris.length; i++) { |
| 693 | clipData.addItem(new ClipData.Item(uris[i])); |
| 694 | } |
| 695 | intent.setClipData(clipData); |
| 696 | } |
Jeff Sharkey | e22d02e | 2013-04-26 16:54:55 -0700 | [diff] [blame] | 697 | |
Jeff Sharkey | b362044 | 2013-09-01 18:41:04 -0700 | [diff] [blame] | 698 | if (mState.action == ACTION_GET_CONTENT) { |
Jeff Sharkey | 1d890e0 | 2013-08-15 11:24:03 -0700 | [diff] [blame] | 699 | intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION); |
Daichi Hirono | caadd41 | 2015-04-10 15:50:38 +0900 | [diff] [blame] | 700 | } else if (mState.action == ACTION_OPEN_TREE || |
| 701 | mState.action == ACTION_OPEN_COPY_DESTINATION) { |
Jeff Sharkey | 6e565ff | 2014-04-05 19:05:24 -0700 | [diff] [blame] | 702 | intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION |
| 703 | | Intent.FLAG_GRANT_WRITE_URI_PERMISSION |
| 704 | | Intent.FLAG_GRANT_PERSISTABLE_URI_PERMISSION |
| 705 | | Intent.FLAG_GRANT_PREFIX_URI_PERMISSION); |
Tomasz Mikolajewski | 2023fcf | 2015-04-10 10:30:33 +0900 | [diff] [blame] | 706 | // TODO: Move passing the stack to the separate ACTION_COPY action once it's implemented. |
| 707 | intent.putExtra(CopyService.EXTRA_STACK, (Parcelable)mState.stack); |
Ben Kwa | cb4461f | 2015-05-05 11:50:11 -0700 | [diff] [blame^] | 708 | intent.putExtra(CopyService.EXTRA_TRANSFER_MODE, mState.transferMode); |
Jeff Sharkey | 1d890e0 | 2013-08-15 11:24:03 -0700 | [diff] [blame] | 709 | } else { |
| 710 | intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION |
| 711 | | Intent.FLAG_GRANT_WRITE_URI_PERMISSION |
Jeff Sharkey | 13d369f | 2013-09-20 14:30:59 -0700 | [diff] [blame] | 712 | | Intent.FLAG_GRANT_PERSISTABLE_URI_PERMISSION); |
Jeff Sharkey | 1d890e0 | 2013-08-15 11:24:03 -0700 | [diff] [blame] | 713 | } |
Jeff Sharkey | e22d02e | 2013-04-26 16:54:55 -0700 | [diff] [blame] | 714 | |
| 715 | setResult(Activity.RESULT_OK, intent); |
| 716 | finish(); |
| 717 | } |
| 718 | |
Steve McKay | b68dd22 | 2015-04-20 17:18:15 -0700 | [diff] [blame] | 719 | public static DocumentsActivity get(Fragment fragment) { |
| 720 | return (DocumentsActivity) fragment.getActivity(); |
| 721 | } |
| 722 | |
| 723 | private final class PickFinishTask extends AsyncTask<Void, Void, Void> { |
| 724 | private final Uri mUri; |
| 725 | |
| 726 | public PickFinishTask(Uri uri) { |
| 727 | mUri = uri; |
| 728 | } |
| 729 | |
| 730 | @Override |
| 731 | protected Void doInBackground(Void... params) { |
| 732 | saveStackBlocking(); |
| 733 | return null; |
| 734 | } |
| 735 | |
| 736 | @Override |
| 737 | protected void onPostExecute(Void result) { |
| 738 | onTaskFinished(mUri); |
| 739 | } |
| 740 | } |
| 741 | |
| 742 | final class ExistingFinishTask extends AsyncTask<Void, Void, Void> { |
| 743 | private final Uri[] mUris; |
| 744 | |
| 745 | public ExistingFinishTask(Uri... uris) { |
| 746 | mUris = uris; |
| 747 | } |
| 748 | |
| 749 | @Override |
| 750 | protected Void doInBackground(Void... params) { |
| 751 | saveStackBlocking(); |
| 752 | return null; |
| 753 | } |
| 754 | |
| 755 | @Override |
| 756 | protected void onPostExecute(Void result) { |
| 757 | onTaskFinished(mUris); |
| 758 | } |
| 759 | } |
| 760 | |
| 761 | /** |
| 762 | * Task that creates a new document in the background. |
| 763 | */ |
| 764 | final class CreateFinishTask extends AsyncTask<Void, Void, Uri> { |
Jeff Sharkey | 9dd0262 | 2013-09-27 16:44:11 -0700 | [diff] [blame] | 765 | private final String mMimeType; |
| 766 | private final String mDisplayName; |
| 767 | |
| 768 | public CreateFinishTask(String mimeType, String displayName) { |
| 769 | mMimeType = mimeType; |
| 770 | mDisplayName = displayName; |
| 771 | } |
| 772 | |
| 773 | @Override |
Jeff Sharkey | 4be51f1 | 2013-10-23 15:46:38 -0700 | [diff] [blame] | 774 | protected void onPreExecute() { |
| 775 | setPending(true); |
| 776 | } |
| 777 | |
| 778 | @Override |
Jeff Sharkey | 9dd0262 | 2013-09-27 16:44:11 -0700 | [diff] [blame] | 779 | protected Uri doInBackground(Void... params) { |
Jeff Sharkey | 3fd1177 | 2013-09-30 14:26:27 -0700 | [diff] [blame] | 780 | final ContentResolver resolver = getContentResolver(); |
Jeff Sharkey | 9dd0262 | 2013-09-27 16:44:11 -0700 | [diff] [blame] | 781 | final DocumentInfo cwd = getCurrentDirectory(); |
Jeff Sharkey | 3fd1177 | 2013-09-30 14:26:27 -0700 | [diff] [blame] | 782 | |
| 783 | ContentProviderClient client = null; |
| 784 | Uri childUri = null; |
| 785 | try { |
| 786 | client = DocumentsApplication.acquireUnstableProviderOrThrow( |
| 787 | resolver, cwd.derivedUri.getAuthority()); |
| 788 | childUri = DocumentsContract.createDocument( |
| 789 | client, cwd.derivedUri, mMimeType, mDisplayName); |
| 790 | } catch (Exception e) { |
| 791 | Log.w(TAG, "Failed to create document", e); |
| 792 | } finally { |
| 793 | ContentProviderClient.releaseQuietly(client); |
| 794 | } |
| 795 | |
Jeff Sharkey | 9dd0262 | 2013-09-27 16:44:11 -0700 | [diff] [blame] | 796 | if (childUri != null) { |
| 797 | saveStackBlocking(); |
| 798 | } |
Jeff Sharkey | 3fd1177 | 2013-09-30 14:26:27 -0700 | [diff] [blame] | 799 | |
Jeff Sharkey | 9dd0262 | 2013-09-27 16:44:11 -0700 | [diff] [blame] | 800 | return childUri; |
| 801 | } |
| 802 | |
| 803 | @Override |
| 804 | protected void onPostExecute(Uri result) { |
| 805 | if (result != null) { |
Steve McKay | b68dd22 | 2015-04-20 17:18:15 -0700 | [diff] [blame] | 806 | onTaskFinished(result); |
Jeff Sharkey | 9dd0262 | 2013-09-27 16:44:11 -0700 | [diff] [blame] | 807 | } else { |
| 808 | Toast.makeText(DocumentsActivity.this, R.string.save_error, Toast.LENGTH_SHORT) |
| 809 | .show(); |
| 810 | } |
Jeff Sharkey | 4be51f1 | 2013-10-23 15:46:38 -0700 | [diff] [blame] | 811 | |
| 812 | setPending(false); |
Jeff Sharkey | 9dd0262 | 2013-09-27 16:44:11 -0700 | [diff] [blame] | 813 | } |
| 814 | } |
Jeff Sharkey | e22d02e | 2013-04-26 16:54:55 -0700 | [diff] [blame] | 815 | } |