Differential D18212 Diff 53433 src/org/kde/kdeconnect/Plugins/SftpPlugin/SftpSettingsFragment.java

Changeset View

Standalone View

View Options

src/org/kde/kdeconnect/Plugins/SftpPlugin/SftpSettingsFragment.java

  • This file was added.
1​/*
2​ * Copyright 2018 Erik Duisters <e.duisters1@gmail.com>
3​ *
4​ * This program is free software; you can redistribute it and/or
5​ * modify it under the terms of the GNU General Public License as
6​ * published by the Free Software Foundation; either version 2 of
7​ * the License or (at your option) version 3 or any later version
8​ * accepted by the membership of KDE e.V. (or its successor approved
9​ * by the membership of KDE e.V.), which shall act as a proxy
10​ * defined in Section 14 of version 3 of the license.
11​ *
12​ * This program is distributed in the hope that it will be useful,
13​ * but WITHOUT ANY WARRANTY; without even the implied warranty of
14​ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15​ * GNU General Public License for more details.
16​ *
17​ * You should have received a copy of the GNU General Public License
18​ * along with this program. If not, see <http://www.gnu.org/licenses/>.
19​ */
20​
21​package org.kde.kdeconnect.Plugins.SftpPlugin;
22​
23​import android.annotation.TargetApi;
24​import android.content.Context;
25​import android.content.Intent;
26​import android.content.SharedPreferences;
27​import android.content.res.TypedArray;
28​import android.graphics.PorterDuff;
29​import android.net.Uri;
30​import android.os.Build;
31​import android.os.Bundle;
32​import android.os.Environment;
33​import android.util.SparseBooleanArray;
34​import android.view.Menu;
35​import android.view.MenuInflater;
36​import android.view.MenuItem;
37​
38​import org.json.JSONArray;
39​import org.json.JSONException;
40​import org.json.JSONObject;
41​import org.kde.kdeconnect.BackgroundService;
42​import org.kde.kdeconnect.Device;
43​import org.kde.kdeconnect.Helpers.StorageHelper;
44​import org.kde.kdeconnect.UserInterface.DeviceSettingsActivity;
45​import org.kde.kdeconnect.UserInterface.PluginSettingsFragment;
46​import org.kde.kdeconnect_tp.R;
47​
48​import java.io.File;
49​import java.util.ArrayList;
50​import java.util.Collections;
51​import java.util.List;
52​import java.util.ListIterator;
53​
54​import androidx.annotation.NonNull;
55​import androidx.appcompat.view.ActionMode;
56​import androidx.fragment.app.Fragment;
57​import androidx.preference.Preference;
58​import androidx.preference.PreferenceCategory;
59​import androidx.preference.PreferenceManager;
60​import androidx.preference.PreferenceScreen;
61​import androidx.recyclerview.widget.RecyclerView;
62​
63​//TODO: Is it possible on API 19 to select a directory and then have write permission for everything beneath it
64​//TODO: Is it necessary to check if uri permissions are still in place? If it is make the user aware of the fact (red text or something)
65​public class SftpSettingsFragment
66​ extends PluginSettingsFragment
67​ implements StoragePreferenceDialogFragment.Callback,
68​ Preference.OnPreferenceChangeListener,
69​ StoragePreference.OnLongClickListener, ActionMode.Callback {
70​ private final static String KEY_STORAGE_PREFERENCE_DIALOG = "StoragePreferenceDialog";
71​ private final static String KEY_ACTION_MODE_STATE = "ActionModeState";
72​ private final static String KEY_ACTION_MODE_ENABLED = "ActionModeEnabled";
73​ private final static String KEY_ACTION_MODE_SELECTED_ITEMS = "ActionModeSelectedItems";
74​
75​ private List<SftpPlugin.StorageInfo> storageInfoList;
76​ private PreferenceCategory preferenceCategory;
77​ private ActionMode actionMode;
78​ private JSONObject savedActionModeState;
79​
80​ public static SftpSettingsFragment newInstance(@NonNull String pluginKey) {
81​ SftpSettingsFragment fragment = new SftpSettingsFragment();
82​ fragment.setArguments(pluginKey);
83​
84​ return fragment;
85​ }
86​
87​ public SftpSettingsFragment() {}
88​
89​ @Override
90​ public void onCreate(Bundle savedInstanceState) {
91​ // super.onCreate creates PreferenceManager and calls onCreatePreferences()
92​ super.onCreate(savedInstanceState);
93​
94​ if (getFragmentManager() != null) {
95​ Fragment fragment = getFragmentManager().findFragmentByTag(KEY_STORAGE_PREFERENCE_DIALOG);
96​ if (fragment != null) {
97​ ((StoragePreferenceDialogFragment) fragment).setCallback(this);
98​ }
99​ }
100​
101​ if (savedInstanceState != null && savedInstanceState.containsKey(KEY_ACTION_MODE_STATE)) {
102​ try {
103​ savedActionModeState = new JSONObject(savedInstanceState.getString(KEY_ACTION_MODE_STATE, "{}"));
104​ } catch (JSONException ignored) {}
105​ }
106​ }
107​
108​ @Override
109​ public void onCreatePreferences(Bundle savedInstanceState, String rootKey) {
110​ super.onCreatePreferences(savedInstanceState, rootKey);
111​
112​ TypedArray ta = requireContext().obtainStyledAttributes(new int[]{R.attr.colorAccent});
113​ int colorAccent = ta.getColor(0, 0);
114​ ta.recycle();
115​
116​ int sdkInt = Build.VERSION.SDK_INT;
117​
118​ storageInfoList = getStorageInfoList(requireContext());
119​
120​ PreferenceScreen preferenceScreen = getPreferenceScreen();
121​ preferenceCategory = (PreferenceCategory) preferenceScreen
122​ .findPreference(getString(R.string.sftp_preference_key_preference_category));
123​
124​ if (sdkInt <= 19) {
125​ preferenceCategory.setTitle(R.string.sftp_preference_detected_sdcards);
126​ } else {
127​ preferenceCategory.setTitle(R.string.sftp_preference_configured_storage_locations);
128​ }
129​
130​ addStoragePreferences(preferenceCategory);
131​
132​ Preference addStoragePreference = preferenceScreen.findPreference(getString(R.string.sftp_preference_key_add_storage));
133​ addStoragePreference.getIcon().setColorFilter(colorAccent, PorterDuff.Mode.SRC_IN);
134​
135​ if (sdkInt <= 19) {
136​ addStoragePreference.setVisible(false);
137​ }
138​
139​ Preference addCameraShortcutPreference = preferenceScreen.findPreference(getString(R.string.sftp_preference_key_add_camera_shortcut));
140​
141​ if (sdkInt > 19) {
142​ addCameraShortcutPreference.setVisible(false);
143​ }
144​ }
145​
146​ private void addStoragePreferences(PreferenceCategory preferenceCategory) {
147​ /*
148​ https://developer.android.com/guide/topics/ui/settings/programmatic-hierarchy
149​ You can't just use any context to create Preferences, you have to use PreferenceManager's context
150​ */
151​ Context context = getPreferenceManager().getContext();
152​
153​ sortStorageInfoListOnDisplayName();
154​
155​ for (int i = 0; i < storageInfoList.size(); i++) {
156​ SftpPlugin.StorageInfo storageInfo = storageInfoList.get(i);
157​ StoragePreference preference = new StoragePreference(context);
158​ preference.setOnPreferenceChangeListener(this);
159​ if (Build.VERSION.SDK_INT >= 21) {
160​ preference.setOnLongClickListener(this);
161​ }
162​ preference.setKey(getString(R.string.sftp_preference_key_storage_info, i));
163​ preference.setIcon(android.R.color.transparent);
164​ preference.setDefaultValue(storageInfo);
165​ if (storageInfo.isFileUri()) {
166​ preference.setDialogTitle(R.string.sftp_preference_edit_sdcard_title);
167​ } else {
168​ preference.setDialogTitle(R.string.sftp_preference_edit_storage_location);
169​ }
170​
171​ preferenceCategory.addPreference(preference);
172​ }
173​ }
174​
175​ @Override
176​ protected RecyclerView.Adapter onCreateAdapter(PreferenceScreen preferenceScreen) {
177​ if (savedActionModeState != null) {
178​ getListView().post(this::restoreActionMode);
179​ }
180​
181​ return super.onCreateAdapter(preferenceScreen);
182​ }
183​
184​ private void restoreActionMode() {
185​ try {
186​ if (savedActionModeState.getBoolean(KEY_ACTION_MODE_ENABLED)) {
187​ actionMode = ((DeviceSettingsActivity)requireActivity()).startSupportActionMode(this);
188​
189​ if (actionMode != null) {
190​ JSONArray jsonArray = savedActionModeState.getJSONArray(KEY_ACTION_MODE_SELECTED_ITEMS);
191​ SparseBooleanArray selectedItems = new SparseBooleanArray();
192​
193​ for (int i = 0, count = jsonArray.length(); i < count; i++) {
194​ selectedItems.put(jsonArray.getInt(i), true);
195​ }
196​
197​ for (int i = 0, count = preferenceCategory.getPreferenceCount(); i < count; i++) {
198​ StoragePreference preference = (StoragePreference) preferenceCategory.getPreference(i);
199​ preference.setSelectable(true);
200​ preference.checkbox.setChecked(selectedItems.get(i, false));
201​ }
202​ }
203​ }
204​
205​ } catch (JSONException ignored) {}
206​ }
207​
208​ @Override
209​ public void onDisplayPreferenceDialog(Preference preference) {
210​ if (preference instanceof StoragePreference) {
211​ StoragePreferenceDialogFragment fragment = StoragePreferenceDialogFragment.newInstance(preference.getKey());
212​ fragment.setTargetFragment(this, 0);
213​ fragment.setCallback(this);
214​ fragment.show(requireFragmentManager(), KEY_STORAGE_PREFERENCE_DIALOG);
215​ } else {
216​ super.onDisplayPreferenceDialog(preference);
217​ }
218​ }
219​
220​ @Override
221​ public void onSaveInstanceState(Bundle outState) {
222​ super.onSaveInstanceState(outState);
223​
224​ try {
225​ JSONObject jsonObject = new JSONObject();
226​
227​ jsonObject.put(KEY_ACTION_MODE_ENABLED, actionMode != null);
228​
229​ if (actionMode != null) {
230​ JSONArray jsonArray = new JSONArray();
231​
232​ for (int i = 0, count = preferenceCategory.getPreferenceCount(); i < count; i++) {
233​ StoragePreference preference = (StoragePreference) preferenceCategory.getPreference(i);
234​ if (preference.checkbox.isChecked()) {
235​ jsonArray.put(i);
236​ }
237​ }
238​
239​ jsonObject.put(KEY_ACTION_MODE_SELECTED_ITEMS, jsonArray);
240​ }
241​
242​ outState.putString(KEY_ACTION_MODE_STATE, jsonObject.toString());
243​ } catch (JSONException ignored) {}
244​ }
245​
246​ private void saveStorageInfoList() {
247​ SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(requireContext());
248​
249​ JSONArray jsonArray = new JSONArray();
250​
251​ try {
252​ for (SftpPlugin.StorageInfo storageInfo : storageInfoList) {
253​ jsonArray.put(storageInfo.toJSON());
254​ }
255​ } catch (JSONException ignored) {}
256​
257​ preferences
258​ .edit()
259​ .putString(requireContext().getString(R.string.sftp_preference_key_storage_info_list), jsonArray.toString())
260​ .apply();
261​ }
262​
263​ @NonNull
264​ static List<SftpPlugin.StorageInfo> getStorageInfoList(@NonNull Context context) {
265​ ArrayList<SftpPlugin.StorageInfo> storageInfoList = new ArrayList<>();
266​
267​ SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(context);
268​
269​ String jsonString = preferences
270​ .getString(context.getString(R.string.sftp_preference_key_storage_info_list), "[]");
271​
272​ try {
273​ JSONArray jsonArray = new JSONArray(jsonString);
274​
275​ for (int i = 0; i < jsonArray.length(); i++) {
276​ storageInfoList.add(SftpPlugin.StorageInfo.fromJSON(jsonArray.getJSONObject(i)));
277​ }
278​ } catch (JSONException e) {
279​ e.printStackTrace();
280​ }
281​
282​ if (Build.VERSION.SDK_INT <= 19) {
283​ addDetectedSDCardsToStorageInfoList(context, storageInfoList);
284​ }
285​
286​ return storageInfoList;
287​ }
288​
289​ private static void addDetectedSDCardsToStorageInfoList(@NonNull Context context, List<SftpPlugin.StorageInfo> storageInfoList) {
290​ List<StorageHelper.StorageInfo> storageHelperInfoList = StorageHelper.getStorageList();
291​
292​ for (StorageHelper.StorageInfo info : storageHelperInfoList) {
293​ // on at least API 17 emulator Environment.isExternalStorageRemovable returns false
294​ if (info.removable || info.path.startsWith(Environment.getExternalStorageDirectory().getPath())) {
295​ StringBuilder displayNameBuilder = new StringBuilder();
296​ StringBuilder displayNameReadOnlyBuilder = new StringBuilder();
297​
298​ Uri sdCardUri = Uri.fromFile(new File(info.path));
299​
300​ if (isAlreadyConfigured(storageInfoList, sdCardUri)) {
301​ continue;
302​ }
303​
304​ int i = 1;
305​
306​ do {
307​ if (i == 1) {
308​ displayNameBuilder.append(context.getString(R.string.sftp_sdcard));
309​ } else {
310​ displayNameBuilder.setLength(0);
311​ displayNameBuilder.append(context.getString(R.string.sftp_sdcard_num, i));
312​ }
313​
314​ displayNameReadOnlyBuilder
315​ .append(displayNameBuilder)
316​ .append(" ")
317​ .append(context.getString(R.string.sftp_readonly));
318​
319​ i++;
320​ } while (!isDisplayNameUnique(storageInfoList, displayNameBuilder.toString(), displayNameReadOnlyBuilder.toString()));
321​
322​ String displayName = info.readonly ?
323​ displayNameReadOnlyBuilder.toString() : displayNameBuilder.toString();
albertvakaUnsubmitted
Done

I can write to the internal phone storage (sdcard0) on API 19, although it appears as read only because of this condition. Maybe you had a different experience while testing?

To simplify this code, since it's only for old APIs, maybe remove appending the "read only" string? It could be that every device is different, and determining if it is actually going to be read-only is difficult. If that's the case, I don't think it's worth trying to get it right just for old APIs.

albertvaka: I can write to the internal phone storage (sdcard0) on API 19, although it appears as read only…
eduistersAuthorUnsubmitted
Not Done

I apparently did not test if writing to API 19 was possible. I just assumed that because writing to sdcard on KitKat was not possible using the File API it was also not possible using SaF.

eduisters: I apparently did not test if writing to API 19 was possible. I just assumed that because…
324​
325​ storageInfoList.add(new SftpPlugin.StorageInfo(displayName, Uri.fromFile(new File(info.path))));
326​ }
327​ }
328​ }
329​
330​ private static boolean isDisplayNameUnique(List<SftpPlugin.StorageInfo> storageInfoList, String displayName, String displayNameReadOnly) {
331​ for (SftpPlugin.StorageInfo info : storageInfoList) {
332​ if (info.displayName.equals(displayName) || info.displayName.equals(displayName + displayNameReadOnly)) {
333​ return false;
334​ }
335​ }
336​
337​ return true;
338​ }
339​
340​ private static boolean isAlreadyConfigured(List<SftpPlugin.StorageInfo> storageInfoList, Uri sdCardUri) {
341​ for (SftpPlugin.StorageInfo info : storageInfoList) {
342​ if (info.uri.equals(sdCardUri)) {
343​ return true;
344​ }
345​ }
346​
347​ return false;
348​ }
349​
350​ private void sortStorageInfoListOnDisplayName() {
351​ Collections.sort(storageInfoList, new SftpPlugin.StorageInfo.DisplayNameComparator());
352​ }
353​
354​ @NonNull
355​ @Override
356​ public StoragePreferenceDialogFragment.CallbackResult isDisplayNameAllowed(@NonNull String displayName) {
357​ StoragePreferenceDialogFragment.CallbackResult result = new StoragePreferenceDialogFragment.CallbackResult();
358​ result.isAllowed = true;
359​
360​ if (displayName.isEmpty()) {
361​ result.isAllowed = false;
362​ result.errorMessage = getString(R.string.sftp_storage_preference_display_name_cannot_be_empty);
363​ } else {
364​ for (SftpPlugin.StorageInfo storageInfo : storageInfoList) {
365​ if (storageInfo.displayName.equals(displayName)) {
366​ result.isAllowed = false;
367​ result.errorMessage = getString(R.string.sftp_storage_preference_display_name_already_used);
368​
369​ break;
370​ }
371​ }
372​ }
373​
374​ return result;
375​ }
376​
377​ @NonNull
378​ @Override
379​ public StoragePreferenceDialogFragment.CallbackResult isUriAllowed(@NonNull Uri uri) {
380​ StoragePreferenceDialogFragment.CallbackResult result = new StoragePreferenceDialogFragment.CallbackResult();
381​ result.isAllowed = true;
382​
383​ for (SftpPlugin.StorageInfo storageInfo : storageInfoList) {
384​ if (storageInfo.uri.equals(uri)) {
385​ result.isAllowed = false;
386​ result.errorMessage = getString(R.string.sftp_storage_preference_storage_location_already_configured);
387​
388​ break;
389​ }
390​ }
391​ return result;
392​ }
393​
394​ @TargetApi(Build.VERSION_CODES.LOLLIPOP)
395​ @Override
396​ public void addNewStoragePreference(@NonNull SftpPlugin.StorageInfo storageInfo, int takeFlags) {
397​ storageInfoList.add(storageInfo);
398​
399​ handleChangedStorageInfoList();
400​
401​ requireContext().getContentResolver().takePersistableUriPermission(storageInfo.uri, takeFlags);
402​ }
403​
404​ private void handleChangedStorageInfoList() {
405​ saveStorageInfoList();
406​
407​ preferenceCategory.removeAll();
408​
409​ addStoragePreferences(preferenceCategory);
410​
411​ Device device = BackgroundService.getInstance().getDevice(getDeviceId());
412​
413​ if (device != null) {
414​ device.reloadPluginsFromSettings();
415​ }
416​ }
417​
418​ @Override
419​ public boolean onPreferenceChange(Preference preference, Object newValue) {
420​ SftpPlugin.StorageInfo newStorageInfo = (SftpPlugin.StorageInfo) newValue;
421​
422​ ListIterator<SftpPlugin.StorageInfo> it = storageInfoList.listIterator();
423​
424​ while (it.hasNext()) {
425​ SftpPlugin.StorageInfo storageInfo = it.next();
426​ if (storageInfo.uri.equals(newStorageInfo.uri)) {
427​ it.set(newStorageInfo);
428​ break;
429​ }
430​ }
431​
432​ handleChangedStorageInfoList();
433​
434​ return false;
435​ }
436​
437​ @Override
438​ public void onLongClick(StoragePreference storagePreference) {
439​ if (actionMode == null) {
440​ actionMode = ((DeviceSettingsActivity)requireActivity()).startSupportActionMode(this);
441​
442​ if (actionMode != null) {
443​ for (int i = 0, count = preferenceCategory.getPreferenceCount(); i < count; i++) {
444​ StoragePreference preference = (StoragePreference) preferenceCategory.getPreference(i);
445​ preference.setSelectable(true);
446​ if (storagePreference.equals(preference)) {
447​ preference.checkbox.setChecked(true);
448​ }
449​ }
450​ }
451​ }
452​ }
453​
454​ @Override
455​ public boolean onCreateActionMode(ActionMode mode, Menu menu) {
456​ MenuInflater inflater = mode.getMenuInflater();
457​ inflater.inflate(R.menu.sftp_settings_action_mode, menu);
458​ return true;
459​ }
460​
461​ @Override
462​ public boolean onPrepareActionMode(ActionMode mode, Menu menu) {
463​ return false;
464​ }
465​
466​ @Override
467​ public boolean onActionItemClicked(ActionMode mode, MenuItem item) {
468​ switch (item.getItemId()) {
469​ case R.id.delete:
470​ for (int count = preferenceCategory.getPreferenceCount(), i = count - 1; i >= 0; i--) {
471​ StoragePreference preference = (StoragePreference) preferenceCategory.getPreference(i);
472​ if (preference.checkbox.isChecked()) {
473​ SftpPlugin.StorageInfo info = storageInfoList.remove(i);
474​
475​ if (Build.VERSION.SDK_INT >= 21) {
476​ requireContext().getContentResolver().releasePersistableUriPermission(info.uri, Intent.FLAG_GRANT_READ_URI_PERMISSION | Intent.FLAG_GRANT_WRITE_URI_PERMISSION);
477​ }
478​ }
479​ }
480​
481​ actionMode.finish(); //This must be called before handleChangedStorageInfoList()
482​ handleChangedStorageInfoList();
483​ return true;
484​ default:
485​ return false;
486​ }
487​ }
488​
489​ @Override
490​ public void onDestroyActionMode(ActionMode mode) {
491​ actionMode = null;
492​
493​ for (int i = 0, count = preferenceCategory.getPreferenceCount(); i < count; i++) {
494​ StoragePreference preference = (StoragePreference) preferenceCategory.getPreference(i);
495​ preference.setSelectable(false);
496​ preference.checkbox.setChecked(false);
497​ }
498​ }
499​}