1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
|
package cgeo.geocaching.utils;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.CharEncoding;
import org.apache.commons.lang3.StringUtils;
import org.eclipse.jdt.annotation.NonNull;
import android.os.Handler;
import android.os.Message;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.util.List;
/**
* Utility class for files
*
*/
public final class FileUtils {
private static final int MAX_DIRECTORY_SCAN_DEPTH = 30;
private static final String FILE_PROTOCOL = "file://";
private FileUtils() {
// utility class
}
public static void listDir(final List<File> result, final File directory, final FileSelector chooser, final Handler feedBackHandler) {
listDirInternally(result, directory, chooser, feedBackHandler, 0);
}
private static void listDirInternally(final List<File> result, final File directory, final FileSelector chooser, final Handler feedBackHandler, final int depths) {
if (directory == null || !directory.isDirectory() || !directory.canRead()
|| result == null
|| chooser == null) {
return;
}
final File[] files = directory.listFiles();
if (ArrayUtils.isNotEmpty(files)) {
for (final File file : files) {
if (chooser.shouldEnd()) {
return;
}
if (!file.canRead()) {
continue;
}
String name = file.getName();
if (file.isFile()) {
if (chooser.isSelected(file)) {
result.add(file); // add file to list
}
} else if (file.isDirectory()) {
if (name.charAt(0) == '.') {
continue; // skip hidden directories
}
if (name.length() > 16) {
name = name.substring(0, 14) + '…';
}
if (feedBackHandler != null) {
feedBackHandler.sendMessage(Message.obtain(feedBackHandler, 0, name));
}
if (depths < MAX_DIRECTORY_SCAN_DEPTH) {
listDirInternally(result, file, chooser, feedBackHandler, depths + 1); // go deeper
}
}
}
}
}
public static boolean deleteDirectory(@NonNull final File dir) {
final File[] files = dir.listFiles();
// Although we are called on an existing directory, it might have been removed concurrently
// in the meantime, for example by the user or by another cleanup task.
if (files != null) {
for (final File file : files) {
if (file.isDirectory()) {
deleteDirectory(file);
} else {
delete(file);
}
}
}
return delete(dir);
}
public static abstract class FileSelector {
public abstract boolean isSelected(File file);
public abstract boolean shouldEnd();
}
/**
* Create a unique non existing file named like the given file name. If a file with the given name already exists,
* add a number as suffix to the file name.<br>
* Example: For the file name "file.ext" this will return the first file of the list
* <ul>
* <li>file.ext</li>
* <li>file_2.ext</li>
* <li>file_3.ext</li>
* </ul>
* which does not yet exist.
*/
public static File getUniqueNamedFile(final File file) {
if (!file.exists()) {
return file;
}
final String baseNameAndPath = file.getPath();
final String prefix = StringUtils.substringBeforeLast(baseNameAndPath, ".") + "_";
final String extension = "." + StringUtils.substringAfterLast(baseNameAndPath, ".");
for (int i = 1; i < Integer.MAX_VALUE; i++) {
final File numbered = new File(prefix + i + extension);
if (!numbered.exists()) {
return numbered;
}
}
throw new IllegalStateException("Unable to generate a non-existing file name");
}
/**
* This usage of this method indicates that the return value of File.delete() can safely be ignored.
*/
public static void deleteIgnoringFailure(final File file) {
final boolean success = file.delete() || !file.exists();
if (!success) {
Log.i("Could not delete " + file.getAbsolutePath());
}
}
/**
* Deletes a file and logs deletion failures.
*
* @return <code> true</code> if this file was deleted, <code>false</code> otherwise.
*/
public static boolean delete(final File file) {
final boolean success = file.delete() || !file.exists();
if (!success) {
Log.e("Could not delete " + file.getAbsolutePath());
}
return success;
}
/**
* Creates the directory named by the given file, creating any missing parent directories in the process.
*
* @return <code>true</code> if the directory was created, <code>false</code> on failure or if the directory already
* existed.
*/
public static boolean mkdirs(final File file) {
final boolean success = file.mkdirs() || file.isDirectory(); // mkdirs returns false on existing directories
if (!success) {
Log.e("Could not make directories " + file.getAbsolutePath());
}
return success;
}
public static boolean writeFileUTF16(final File file, final String content) {
// TODO: replace by some apache.commons IOUtils or FileUtils code
Writer fileWriter = null;
BufferedOutputStream buffer = null;
try {
final OutputStream os = new FileOutputStream(file);
buffer = new BufferedOutputStream(os);
fileWriter = new OutputStreamWriter(buffer, CharEncoding.UTF_16);
fileWriter.write(content);
} catch (final IOException e) {
Log.e("FieldnoteExport.ExportTask export", e);
return false;
} finally {
IOUtils.closeQuietly(fileWriter);
IOUtils.closeQuietly(buffer);
}
return true;
}
/**
* Check if the URL represents a file on the local file system.
*
* @return <tt>true</tt> if the URL scheme is <tt>file</tt>, <tt>false</tt> otherwise
*/
public static boolean isFileUrl(final String url) {
return StringUtils.startsWith(url, FILE_PROTOCOL);
}
/**
* Build an URL from a file name.
*
* @param file a local file name
* @return an URL with the <tt>file</tt> scheme
*/
public static String fileToUrl(final File file) {
return FILE_PROTOCOL + file.getAbsolutePath();
}
/**
* Local file name when {@link #isFileUrl(String)} is <tt>true</tt>.
*
* @return the local file
*/
public static File urlToFile(final String url) {
return new File(StringUtils.substring(url, FILE_PROTOCOL.length()));
}
}
|
