269 lines
8.3 KiB
Java
269 lines
8.3 KiB
Java
/*
|
|
* Copyright (c) 2015 Jonas Kalderstam
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Lesser General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
package com.nononsenseapps.filepicker;
|
|
|
|
import android.net.Uri;
|
|
import android.os.FileObserver;
|
|
import android.support.v4.content.AsyncTaskLoader;
|
|
import android.support.v4.content.Loader;
|
|
import android.support.v7.util.SortedList;
|
|
import android.support.v7.widget.util.SortedListAdapterCallback;
|
|
import android.widget.Toast;
|
|
|
|
import java.io.File;
|
|
|
|
/**
|
|
* An implementation of the picker which allows you to select a file from the internal/external
|
|
* storage (SD-card) on a device.
|
|
*/
|
|
public class FilePickerFragment extends AbstractFilePickerFragment<File> {
|
|
|
|
public FilePickerFragment() {
|
|
}
|
|
|
|
/**
|
|
* Return true if the path is a directory and not a file.
|
|
*
|
|
* @param path either a file or directory
|
|
* @return true if path is a directory, false if file
|
|
*/
|
|
@Override
|
|
public boolean isDir(final File path) {
|
|
return path.isDirectory();
|
|
}
|
|
|
|
/**
|
|
* @param path either a file or directory
|
|
* @return filename of path
|
|
*/
|
|
@Override
|
|
public String getName(File path) {
|
|
return path.getName();
|
|
}
|
|
|
|
/**
|
|
* Return the path to the parent directory. Should return the root if
|
|
* from is root.
|
|
*
|
|
* @param from either a file or directory
|
|
* @return the parent directory
|
|
*/
|
|
@Override
|
|
public File getParent(final File from) {
|
|
if (from.getPath().equals(getRoot().getPath())) {
|
|
// Already at root, we can't go higher
|
|
return from;
|
|
} else if (from.getParentFile() != null) {
|
|
if (from.isFile()) {
|
|
return getParent(from.getParentFile());
|
|
} else {
|
|
return from.getParentFile();
|
|
}
|
|
} else {
|
|
return from;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Convert the path to the type used.
|
|
*
|
|
* @param path either a file or directory
|
|
* @return File representation of the string path
|
|
*/
|
|
@Override
|
|
public File getPath(final String path) {
|
|
return new File(path);
|
|
}
|
|
|
|
/**
|
|
* @param path either a file or directory
|
|
* @return the full path to the file
|
|
*/
|
|
@Override
|
|
public String getFullPath(final File path) {
|
|
return path.getPath();
|
|
}
|
|
|
|
/**
|
|
* Get the root path.
|
|
*
|
|
* @return the highest allowed path, which is "/" by default
|
|
*/
|
|
@Override
|
|
public File getRoot() {
|
|
return new File("/");
|
|
}
|
|
|
|
/**
|
|
* Convert the path to a URI for the return intent
|
|
*
|
|
* @param file either a file or directory
|
|
* @return a Uri
|
|
*/
|
|
@Override
|
|
public Uri toUri(final File file) {
|
|
return Uri.fromFile(file);
|
|
}
|
|
|
|
/**
|
|
* Get a loader that lists the Files in the current path,
|
|
* and monitors changes.
|
|
*/
|
|
@Override
|
|
public Loader<SortedList<File>> getLoader() {
|
|
return new AsyncTaskLoader<SortedList<File>>(getActivity()) {
|
|
|
|
FileObserver fileObserver;
|
|
|
|
@Override
|
|
public SortedList<File> loadInBackground() {
|
|
File[] listFiles = currentPath.listFiles();
|
|
final int initCap = listFiles == null ? 0 : listFiles.length;
|
|
|
|
SortedList<File> files = new SortedList<>(File.class, new SortedListAdapterCallback<File>(getDummyAdapter()) {
|
|
@Override
|
|
public int compare(File lhs, File rhs) {
|
|
return compareFiles(lhs, rhs);
|
|
}
|
|
|
|
@Override
|
|
public boolean areContentsTheSame(File file, File file2) {
|
|
return file.getAbsolutePath().equals(file2.getAbsolutePath()) && (file.isFile() == file2.isFile());
|
|
}
|
|
|
|
@Override
|
|
public boolean areItemsTheSame(File file, File file2) {
|
|
return areContentsTheSame(file, file2);
|
|
}
|
|
}, initCap);
|
|
|
|
|
|
files.beginBatchedUpdates();
|
|
if (listFiles != null) {
|
|
for (java.io.File f : listFiles) {
|
|
if (isItemVisible(f)) {
|
|
files.add(f);
|
|
}
|
|
}
|
|
}
|
|
files.endBatchedUpdates();
|
|
|
|
return files;
|
|
}
|
|
|
|
/**
|
|
* Handles a request to start the Loader.
|
|
*/
|
|
@Override
|
|
protected void onStartLoading() {
|
|
super.onStartLoading();
|
|
|
|
// handle if directory does not exist. Fall back to root.
|
|
if (currentPath == null || !currentPath.isDirectory()) {
|
|
currentPath = getRoot();
|
|
}
|
|
|
|
// Start watching for changes
|
|
fileObserver = new FileObserver(currentPath.getPath(),
|
|
FileObserver.CREATE |
|
|
FileObserver.DELETE
|
|
| FileObserver.MOVED_FROM | FileObserver.MOVED_TO
|
|
) {
|
|
|
|
@Override
|
|
public void onEvent(int event, String path) {
|
|
// Reload
|
|
onContentChanged();
|
|
}
|
|
};
|
|
fileObserver.startWatching();
|
|
|
|
forceLoad();
|
|
}
|
|
|
|
/**
|
|
* Handles a request to completely reset the Loader.
|
|
*/
|
|
@Override
|
|
protected void onReset() {
|
|
super.onReset();
|
|
|
|
// Stop watching
|
|
if (fileObserver != null) {
|
|
fileObserver.stopWatching();
|
|
fileObserver = null;
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Name is validated to be non-null, non-empty and not containing any
|
|
* slashes.
|
|
*
|
|
* @param name The name of the folder the user wishes to create.
|
|
*/
|
|
@Override
|
|
public void onNewFolder(final String name) {
|
|
File folder = new File(currentPath, name);
|
|
|
|
if (folder.mkdir()) {
|
|
currentPath = folder;
|
|
refresh();
|
|
} else {
|
|
Toast.makeText(getActivity(), R.string.nnf_create_folder_error,
|
|
Toast.LENGTH_SHORT).show();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Used by the list to determine whether a file should be displayed or not.
|
|
* Default behavior is to always display folders. If files can be selected,
|
|
* then files are also displayed. Override this method to enable other
|
|
* filtering behaviour, like only displaying files with specific extensions (.zip, .txt, etc).
|
|
*
|
|
* @param file to maybe add. Can be either a directory or file.
|
|
* @return True if item should be added to the list, false otherwise
|
|
*/
|
|
protected boolean isItemVisible(final File file) {
|
|
return isDir(file) || (mode == MODE_FILE || mode == MODE_FILE_AND_DIR);
|
|
}
|
|
|
|
/**
|
|
* Compare two files to determine their relative sort order. This follows the usual
|
|
* comparison interface. Override to determine your own custom sort order.
|
|
*
|
|
* Default behaviour is to place directories before files, but sort them alphabetically
|
|
* otherwise.
|
|
*
|
|
* @param lhs File on the "left-hand side"
|
|
* @param rhs File on the "right-hand side"
|
|
* @return -1 if if lhs should be placed before rhs, 0 if they are equal,
|
|
* and 1 if rhs should be placed before lhs
|
|
*/
|
|
protected int compareFiles(File lhs, File rhs) {
|
|
if (lhs.isDirectory() && !rhs.isDirectory()) {
|
|
return -1;
|
|
} else if (rhs.isDirectory() && !lhs.isDirectory()) {
|
|
return 1;
|
|
} else {
|
|
return lhs.getName().compareToIgnoreCase(rhs.getName());
|
|
}
|
|
}
|
|
}
|