Java tutorial
/* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ package cn.tycoon.lighttrans.fileManager; import android.Manifest; import android.content.pm.PackageManager; import android.net.Uri; import android.os.FileObserver; import android.support.annotation.NonNull; import android.support.v4.content.AsyncTaskLoader; import android.support.v4.content.ContextCompat; 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; import cn.tycoon.lighttrans.R; /** * 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> { protected static final int PERMISSIONS_REQUEST_WRITE_EXTERNAL_STORAGE = 1; protected boolean showHiddenItems = false; public FilePickerFragment() { } /** * This method is used to dictate whether hidden files and folders should be shown or not * * @param showHiddenItems whether hidden items should be shown or not */ public void showHiddenItems(boolean showHiddenItems) { this.showHiddenItems = showHiddenItems; } /** * Returns if hidden items are shown or not * * @return true if hidden items are shown, otherwise false */ public boolean areHiddenItemsShown() { return showHiddenItems; } /** * @return true if app has been granted permission to write to the SD-card. */ @Override protected boolean hasPermission() { // return PackageManager.PERMISSION_GRANTED == // ContextCompat.checkSelfPermission(getContext(), // Manifest.permission.WRITE_EXTERNAL_STORAGE); return true; } /** * Request permission to write to the SD-card. */ protected void handlePermission() { // Should we show an explanation? // if (shouldShowRequestPermissionRationale( // Manifest.permission.WRITE_EXTERNAL_STORAGE)) { // Explain to the user why we need permission // } // requestPermissions(new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE}, // PERMISSIONS_REQUEST_WRITE_EXTERNAL_STORAGE); } /** * This the method that gets notified when permission is granted/denied. By default, * a granted request will result in a refresh of the list. * * @param requestCode the code you requested * @param permissions array of permissions you requested. empty if process was cancelled. * @param grantResults results for requests. empty if process was cancelled. */ // @Override // public void onRequestPermissionsResult(int requestCode, // @NonNull String[] permissions, // @NonNull int[] grantResults) { // // If arrays are empty, then process was cancelled // if (permissions.length == 0) { // // Treat this as a cancel press // if (mListener != null) { // mListener.onCancelled(); // } // } else { // if (requestCode == PERMISSIONS_REQUEST_WRITE_EXTERNAL_STORAGE) { // if (PackageManager.PERMISSION_GRANTED == grantResults[0]) { // // Do refresh // refresh(); // } else { // Toast.makeText(getContext(), R.string.permission_external_write_denied, // Toast.LENGTH_SHORT).show(); // // Treat this as a cancel press // if (mListener != null) { // mListener.onCancelled(); // } // } // } // } /** * 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 = mCurrentPath.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 (mCurrentPath == null || !mCurrentPath.isDirectory()) { mCurrentPath = getRoot(); } // Start watching for changes fileObserver = new FileObserver(mCurrentPath.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(mCurrentPath, name); if (folder.mkdir()) { mCurrentPath = folder; refresh(); } else { Toast.makeText(getActivity(), R.string.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. Set the showHiddenFiles property to show * hidden file. Default behaviour is to hide hidden files. 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) { if (!showHiddenItems && file.isHidden()) { return false; } 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. * <p/> * 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()); } } }