再次选择Android文件对话框

我的问题和这篇文章完全一样

我没有看到任何真正有用的答案

理想情况下，我想要一个简单对话框的简单java代码示例，它可以像MFC CFileDialog类一样工作，也就是说，您只需新建它，执行.show，它就可以工作了

到目前为止，我所看到的一切看起来都过于复杂，因为这应该是一项非常简单的工作。有人能提供更多最新信息吗

谢谢

更新

在那个岗位上

---

基里尔·米哈伊洛夫（Kirill Mikhailov）的答案在几分钟的测试后似乎运行良好

我在该示例中添加了一个取消按钮，似乎运行良好

import java.io.File;
import java.io.FilenameFilter;
import java.util.ArrayList;
import java.util.List;

import com.design2112.tabtrax.ListenerList.FireHandler;

import android.app.Activity;
import android.app.AlertDialog;
import android.app.Dialog;
import android.content.DialogInterface;
import android.os.Environment;

public class FileDialog {
    private static final String PARENT_DIR = "..";
    private final String TAG = getClass().getName();
    private String[] fileList;
    private File currentPath;

    public interface FileSelectedListener {
        void fileSelected(File file);
    }

    public interface DirectorySelectedListener {
        void directorySelected(File directory);
    }

    private ListenerList<FileSelectedListener> fileListenerList = new ListenerList<FileDialog.FileSelectedListener>();
    private ListenerList<DirectorySelectedListener> dirListenerList = new ListenerList<FileDialog.DirectorySelectedListener>();
    private final Activity activity;
    private boolean selectDirectoryOption;
    private String fileEndsWith;

    /**
     * @param activity
     * @param initialPath
     */
    public FileDialog(Activity activity, String path) {
        this.activity = activity; 
        loadFileList(new File(path));
    }

    /**
     * @return file dialog
     */
    public Dialog createFileDialog() {
        Dialog dialog = null;
        AlertDialog.Builder builder = new AlertDialog.Builder(activity);

        builder.setTitle(currentPath.getPath());
        /*
         * if (selectDirectoryOption) {
         * builder.setPositiveButton("Select directory", new OnClickListener() {
         * public void onClick(DialogInterface dialog, int which) { Log.d(TAG,
         * currentPath.getPath()); fireDirectorySelectedEvent(currentPath); }
         * }); }
         */

        builder.setItems(fileList, new DialogInterface.OnClickListener() {
            public void onClick(DialogInterface dialog, int which) {
                String fileChosen = fileList[which];
                File chosenFile = getChosenFile(fileChosen);
                if (chosenFile.isDirectory()) {
                    loadFileList(chosenFile);
                    dialog.cancel();
                    dialog.dismiss();
                    showDialog();
                } else
                    fireFileSelectedEvent(chosenFile);
            }
        });
        builder.setNegativeButton("Cancel", new DialogInterface.OnClickListener() {
            public void onClick(DialogInterface dialog, int which) { 
                dialog.dismiss();
            }
        });
        dialog = builder.show();
        return dialog;
    }

    public void addFileListener(FileSelectedListener listener) {
        fileListenerList.add(listener);
    }

    public void removeFileListener(FileSelectedListener listener) {
        fileListenerList.remove(listener);
    }

    public void setSelectDirectoryOption(boolean selectDirectoryOption) {
        this.selectDirectoryOption = selectDirectoryOption;
    }

    public void addDirectoryListener(DirectorySelectedListener listener) {
        dirListenerList.add(listener);
    }

    public void removeDirectoryListener(DirectorySelectedListener listener) {
        dirListenerList.remove(listener);
    }

    /**
     * Show file dialog
     */
    public void showDialog() {
        createFileDialog().show();
    }

    private void fireFileSelectedEvent(final File file) {
        fileListenerList.fireEvent(new FireHandler<FileDialog.FileSelectedListener>() {
            public void fireEvent(FileSelectedListener listener) {
                listener.fileSelected(file);
            }
        });
    }

    private void fireDirectorySelectedEvent(final File directory) {
        dirListenerList.fireEvent(new FireHandler<FileDialog.DirectorySelectedListener>() {
            public void fireEvent(DirectorySelectedListener listener) {
                listener.directorySelected(directory);
            }
        });
    }

    private void loadFileList(File path) {
        this.currentPath = path;
        List<String> r = new ArrayList<String>();
        if (path.exists()) {
            if (path.getParentFile() != null)
                r.add(PARENT_DIR);
            FilenameFilter filter = new FilenameFilter() {
                public boolean accept(File dir, String filename) {
                    File sel = new File(dir, filename);
                    if (!sel.canRead())
                        return false;
                    if (selectDirectoryOption)
                        return sel.isDirectory();
                    else {
                        boolean endsWith = fileEndsWith != null ? filename
                                .toLowerCase().endsWith(fileEndsWith) : true;
                        return endsWith || sel.isDirectory();
                    }
                }
            };
            String[] fileList1 = path.list(filter);
            for (String file : fileList1) {
                r.add(file);
            }
        }
        fileList = (String[]) r.toArray(new String[] {});
    }

    private File getChosenFile(String fileChosen) {
        if (fileChosen.equals(PARENT_DIR))
            return currentPath.getParentFile();
        else
            return new File(currentPath, fileChosen);
    }

    public void setFileEndsWith(String fileEndsWith) {
        this.fileEndsWith = fileEndsWith != null ? fileEndsWith.toLowerCase()
                : fileEndsWith;
    }
}

class ListenerList<L> {
    private List<L> listenerList = new ArrayList<L>();

    public interface FireHandler<L> {
        void fireEvent(L listener);
    }

    public void add(L listener) {
        listenerList.add(listener);
    }

    public void fireEvent(FireHandler<L> fireHandler) {
        List<L> copy = new ArrayList<L>(listenerList);
        for (L l : copy) {
            fireHandler.fireEvent(l);
        }
    }

    public void remove(L listener) {
        listenerList.remove(listener);
    }

    public List<L> getListenerList() {
        return listenerList;
    }
}

导入java.io.File；
导入java.io.FilenameFilter；
导入java.util.ArrayList；
导入java.util.List；
导入com.design2112.tabtrax.ListenerList.FireHandler；
导入android.app.Activity；
导入android.app.AlertDialog；
导入android.app.Dialog；
导入android.content.DialogInterface；
导入android.os.Environment；
公共类文件对话框{
私有静态最终字符串PARENT_DIR=“…”；
私有最终字符串标记=getClass（）.getName（）；
私有字符串[]文件列表；
私有文件路径；
公共接口文件SelectedListener{
选择的无效文件（文件）；
}
公共接口目录SelectedListener{
已选择无效目录（文件目录）；
}
私有ListenerList fileListenerList=新建ListenerList（）；
私有ListenerList dirListenerList=新建ListenerList（）；
私人最终活动；
私有布尔selectDirectoryOption；
私有字符串fileEndsWith；
/**
*@param活动
*@param initialPath
*/
公共文件对话框（活动，字符串路径）{
这个。活动=活动；
loadFileList（新文件（路径））；
}
/**
*@返回文件对话框
*/
公共对话框createFileDialog（）{
Dialog=null；
AlertDialog.Builder=新建AlertDialog.Builder（活动）；
setTitle（currentPath.getPath（））；
/*
*如果（选择目录选项）{
*setPositiveButton（“选择目录”，新建OnClickListener（））{
*public void onClick（DialogInterface dialog，int）{Log.d（TAG，
*currentPath.getPath（）；fireDirectorySelectedEvent（currentPath）；}
* }); }
*/
setItems（文件列表，新的DialogInterface.OnClickListener（）{
public void onClick（DialogInterface dialog，int which）{
字符串fileselected=fileList[which]；
File chosenFile=getChosenFile（fileselected）；
if（chosenFile.isDirectory（））{
loadFileList（chosenFile）；
dialog.cancel（）；
dialog.dismise（）；
showDialog（）；
}否则
fireFileSelectedEvent（chosenFile）；
}
});
setNegativeButton（“取消”，新建DialogInterface.OnClickListener（））{
public void onClick（DialogInterface dialog，int其中）{
dialog.dismise（）；
}
});
dialog=builder.show（）；
返回对话框；
}
public void addFileListener（FileSelectedListener侦听器）{
添加（监听器）；
}
public void removeFileListener（FileSelectedListener侦听器）{
fileListenerList.remove（侦听器）；
}
public void setSelectDirectoryOption（布尔selectDirectoryOption）{
this.selectDirectoryOption=selectDirectoryOption；
}
public void addDirectoryListener（DirectorySelectedListener侦听器）{
添加（监听器）；
}
public void removedDirectoryListener（DirectorySelectedListener侦听器）{
删除（监听器）；
}
/**
*显示文件对话框
*/
公共对话框（）{
createFileDialog（）.show（）；
}
私有void fireFileSelectedEvent（最终文件）{
fireEvent（新的FireHandler（）{
public void fireEvent（FileSelectedListener侦听器）{
fileSelected（文件）；
}
});
}
私有void fireDirectorySelectedEvent（最终文件目录）{
fireEvent（新的FireHandler（））{
public void fireEvent（DirectorySelectedListener侦听器）{
listener.directorySelected（目录）；
}
});
}
私有void加载文件列表（文件路径）{
this.currentPath=path；
列表r=新的ArrayList（）；
if（path.exists（））{
if（path.getParentFile（）！=null）
r、 添加（父目录）；
FilenameFilter筛选器=新建FilenameFilter（）{
公共布尔接受（文件目录，字符串文件名）{
文件选择=新文件（目录，文件名）；
如果（！sel.canRead（））
返回false；
如果（选择目录选项）
返回sel.isDirectory（）；
否则{
布尔值endsWith=fileEndsWith！=null？文件名
.toLowerCase（）.endsWith（fileEndsWith）：true；
返回endsWith | | sel.isDirectory（）；
}
}
};
字符串[]fileList1=path.list（过滤器）；
for（字符串文件：fileList1）{
r、 添加（文件）；
}
}
fileList=（字符串[]）r.toArray（新字符串[]{}）；
}
私有文件getChosenFile（选择字符串文件）{
if（fileselected.equals（PARENT_DIR））
返回currentPath.getParentFile（）；
其他的
返回新文件（currentPath，FileSelected）；
}
公共void setFileEndsWith（字符串fileEndsWith）{
this.fileEndsWith=fileEndsWith！=null？fileEndsWith.toLowerCase（）
：fileEndsWith；
}
}
类侦听器列表{
私有列表listenerList=新的ArrayList（）；
公开