cn.tycoon.lighttrans.fileManager.FilePickerFragment.java Source code

Java tutorial

Introduction

Here is the source code for cn.tycoon.lighttrans.fileManager.FilePickerFragment.java

Source

/*
 * 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());
        }
    }
}