| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package java.io; |
| |
| import java.net.URI; |
| import java.net.URISyntaxException; |
| import java.net.URL; |
| import java.security.AccessController; |
| import java.util.ArrayList; |
| // BEGIN android-added |
| import java.util.Collections; |
| // END android-added |
| import java.util.List; |
| |
| // BEGIN android-removed |
| // import org.apache.harmony.luni.util.DeleteOnExit; |
| // END android-removed |
| import org.apache.harmony.luni.util.Msg; |
| import org.apache.harmony.luni.util.PriviAction; |
| import org.apache.harmony.luni.util.Util; |
| |
| /** |
| * An "abstract" representation of a file system entity identified by a |
| * pathname. The pathname may be absolute (relative to the root directory |
| * of the file system) or relative to the current directory in which the program |
| * is running. |
| * <p> |
| * This class provides methods for querying/changing information about the file |
| * as well as directory listing capabilities if the file represents a directory. |
| * <p> |
| * When manipulating file paths, the static fields of this class may be used to |
| * determine the platform specific separators. |
| * |
| * @see java.io.Serializable |
| * @see java.lang.Comparable |
| * |
| * @since Android 1.0 |
| */ |
| public class File implements Serializable, Comparable<File> { |
| private static final long serialVersionUID = 301077366599181567L; |
| |
| private String path; |
| |
| transient byte[] properPath; |
| |
| /** |
| * The system dependent file separator character. Since Android is a Unix- |
| * based system, this defaults to '/'. |
| * |
| * @since Android 1.0 |
| */ |
| public static final char separatorChar; |
| |
| /** |
| * The system dependent file separator string. The initial value of this |
| * field is the system property "file.separator". Since Android is a Unix- |
| * based system, this defaults to "/". |
| * |
| * @since Android 1.0 |
| */ |
| public static final String separator; |
| |
| /** |
| * The system dependent path separator character. Since Android is a Unix- |
| * based system, this defaults to ':'. |
| * |
| * @since Android 1.0 |
| */ |
| public static final char pathSeparatorChar; |
| |
| /** |
| * The system dependent path separator string. The initial value of this |
| * field is the system property "path.separator". Since Android is a Unix- |
| * based system, this defaults to ':'. |
| * |
| * @since Android 1.0 |
| */ |
| public static final String pathSeparator; |
| |
| /* Temp file counter */ |
| private static int counter; |
| |
| private static boolean caseSensitive; |
| |
| private static native void oneTimeInitialization(); |
| |
| static { |
| oneTimeInitialization(); |
| |
| // The default protection domain grants access to these properties |
| // BEGIN android-changed |
| // We're on linux so the filesystem is case sensitive and the separator is /. |
| separatorChar = System.getProperty("file.separator", "/").charAt(0); //$NON-NLS-1$ //$NON-NLS-2$ |
| pathSeparatorChar = System.getProperty("path.separator", ";").charAt(0); //$NON-NLS-1$//$NON-NLS-2$ |
| separator = new String(new char[] { separatorChar }, 0, 1); |
| pathSeparator = new String(new char[] { pathSeparatorChar }, 0, 1); |
| caseSensitive = true; |
| // END android-changed |
| } |
| |
| /** |
| * Constructs a new file using the specified directory and name. |
| * |
| * @param dir |
| * the directory where the file is stored. |
| * @param name |
| * the file's name. |
| * @throws NullPointerException |
| * if {@code name} is null. |
| * @since Android 1.0 |
| */ |
| public File(File dir, String name) { |
| if (name == null) { |
| throw new NullPointerException(); |
| } |
| if (dir == null) { |
| this.path = fixSlashes(name); |
| } else { |
| this.path = calculatePath(dir.getPath(), name); |
| } |
| } |
| |
| /** |
| * Constructs a new file using the specified path. |
| * |
| * @param path |
| * the path to be used for the file. |
| * @since Android 1.0 |
| */ |
| public File(String path) { |
| // path == null check & NullPointerException thrown by fixSlashes |
| this.path = fixSlashes(path); |
| } |
| |
| /** |
| * Constructs a new File using the specified directory path and file name, |
| * placing a path separator between the two. |
| * |
| * @param dirPath |
| * the path to the directory where the file is stored. |
| * @param name |
| * the file's name. |
| * @throws NullPointerException |
| * if {@code name} is null. |
| * @since Android 1.0 |
| */ |
| public File(String dirPath, String name) { |
| if (name == null) { |
| throw new NullPointerException(); |
| } |
| if (dirPath == null) { |
| this.path = fixSlashes(name); |
| } else { |
| this.path = calculatePath(dirPath, name); |
| } |
| } |
| |
| /** |
| * Constructs a new File using the path of the specified URI. {@code uri} |
| * needs to be an absolute and hierarchical Unified Resource Identifier with |
| * file scheme and non-empty path component, but with undefined authority, |
| * query or fragment components. |
| * |
| * @param uri |
| * the Unified Resource Identifier that is used to construct this |
| * file. |
| * @throws IllegalArgumentException |
| * if {@code uri} does not comply with the conditions above. |
| * @see #toURI |
| * @see java.net.URI |
| * @since Android 1.0 |
| */ |
| public File(URI uri) { |
| // check pre-conditions |
| checkURI(uri); |
| this.path = fixSlashes(uri.getPath()); |
| } |
| |
| private String calculatePath(String dirPath, String name) { |
| dirPath = fixSlashes(dirPath); |
| if (!name.equals("")) { //$NON-NLS-1$ |
| // Remove all the proceeding separator chars from name |
| name = fixSlashes(name); |
| |
| int separatorIndex = 0; |
| while ((separatorIndex < name.length()) |
| && (name.charAt(separatorIndex) == separatorChar)) { |
| separatorIndex++; |
| } |
| if (separatorIndex > 0) { |
| name = name.substring(separatorIndex, name.length()); |
| } |
| |
| // Ensure there is a separator char between dirPath and name |
| if (dirPath.length() > 0 |
| && (dirPath.charAt(dirPath.length() - 1) == separatorChar)) { |
| return dirPath + name; |
| } |
| return dirPath + separatorChar + name; |
| } |
| |
| return dirPath; |
| } |
| |
| private void checkURI(URI uri) { |
| if (!uri.isAbsolute()) { |
| throw new IllegalArgumentException(Msg.getString("K031a", uri)); //$NON-NLS-1$ |
| } else if (!uri.getRawSchemeSpecificPart().startsWith("/")) { //$NON-NLS-1$ |
| throw new IllegalArgumentException(Msg.getString("K031b", uri)); //$NON-NLS-1$ |
| } |
| |
| String temp = uri.getScheme(); |
| if (temp == null || !temp.equals("file")) { //$NON-NLS-1$ |
| throw new IllegalArgumentException(Msg.getString("K031c", uri)); //$NON-NLS-1$ |
| } |
| |
| temp = uri.getRawPath(); |
| if (temp == null || temp.length() == 0) { |
| throw new IllegalArgumentException(Msg.getString("K031d", uri)); //$NON-NLS-1$ |
| } |
| |
| if (uri.getRawAuthority() != null) { |
| throw new IllegalArgumentException(Msg.getString( |
| "K031e", new String[] { "authority", uri.toString() })); //$NON-NLS-1$ //$NON-NLS-2$ |
| } |
| |
| if (uri.getRawQuery() != null) { |
| throw new IllegalArgumentException(Msg.getString( |
| "K031e", new String[] { "query", uri.toString() })); //$NON-NLS-1$//$NON-NLS-2$ |
| } |
| |
| if (uri.getRawFragment() != null) { |
| throw new IllegalArgumentException(Msg.getString( |
| "K031e", new String[] { "fragment", uri.toString() })); //$NON-NLS-1$ //$NON-NLS-2$ |
| } |
| } |
| |
| private static native byte[][] rootsImpl(); |
| |
| private static native boolean isCaseSensitiveImpl(); |
| |
| /** |
| * Lists the file system roots. The Java platform may support zero or more |
| * file systems, each with its own platform-dependent root. Further, the |
| * canonical pathname of any file on the system will always begin with one |
| * of the returned file system roots. |
| * |
| * @return the array of file system roots. |
| * @since Android 1.0 |
| */ |
| public static File[] listRoots() { |
| byte[][] rootsList = rootsImpl(); |
| if (rootsList == null) { |
| return new File[0]; |
| } |
| File result[] = new File[rootsList.length]; |
| for (int i = 0; i < rootsList.length; i++) { |
| result[i] = new File(Util.toString(rootsList[i])); |
| } |
| return result; |
| } |
| |
| /** |
| * The purpose of this method is to take a path and fix the slashes up. This |
| * includes changing them all to the current platforms fileSeparator and |
| * removing duplicates. |
| */ |
| private String fixSlashes(String origPath) { |
| int uncIndex = 1; |
| int length = origPath.length(), newLength = 0; |
| if (separatorChar == '/') { |
| uncIndex = 0; |
| } else if (length > 2 && origPath.charAt(1) == ':') { |
| uncIndex = 2; |
| } |
| |
| boolean foundSlash = false; |
| char newPath[] = origPath.toCharArray(); |
| for (int i = 0; i < length; i++) { |
| char pathChar = newPath[i]; |
| if (pathChar == '\\' || pathChar == '/') { |
| /* UNC Name requires 2 leading slashes */ |
| if ((foundSlash && i == uncIndex) || !foundSlash) { |
| newPath[newLength++] = separatorChar; |
| foundSlash = true; |
| } |
| } else { |
| // check for leading slashes before a drive |
| if (pathChar == ':' |
| && uncIndex > 0 |
| && (newLength == 2 || (newLength == 3 && newPath[1] == separatorChar)) |
| && newPath[0] == separatorChar) { |
| newPath[0] = newPath[newLength - 1]; |
| newLength = 1; |
| // allow trailing slash after drive letter |
| uncIndex = 2; |
| } |
| newPath[newLength++] = pathChar; |
| foundSlash = false; |
| } |
| } |
| // remove trailing slash |
| if (foundSlash |
| && (newLength > (uncIndex + 1) || (newLength == 2 && newPath[0] != separatorChar))) { |
| newLength--; |
| } |
| String tempPath = new String(newPath, 0, newLength); |
| // If it's the same keep it identical for SecurityManager purposes |
| if (!tempPath.equals(origPath)) { |
| return tempPath; |
| } |
| return origPath; |
| } |
| |
| /** |
| * Indicates whether the current context is allowed to read from this file. |
| * |
| * @return {@code true} if this file can be read, {@code false} otherwise. |
| * @throws SecurityException |
| * if a {@code SecurityManager} is installed and it denies the |
| * read request. |
| * @since Android 1.0 |
| */ |
| public boolean canRead() { |
| SecurityManager security = System.getSecurityManager(); |
| if (security != null) { |
| security.checkRead(path); |
| } |
| // BEGIN android-changed |
| return exists() && isReadableImpl(properPath(true)); |
| // END android-changed |
| } |
| |
| /** |
| * Indicates whether the current context is allowed to write to this file. |
| * |
| * @return {@code true} if this file can be written, {@code false} |
| * otherwise. |
| * @throws SecurityException |
| * if a {@code SecurityManager} is installed and it denies the |
| * write request. |
| * @since Android 1.0 |
| */ |
| public boolean canWrite() { |
| SecurityManager security = System.getSecurityManager(); |
| if (security != null) { |
| security.checkWrite(path); |
| } |
| |
| // Cannot use exists() since that does an unwanted read-check. |
| boolean exists = false; |
| if (path.length() > 0) { |
| exists = existsImpl(properPath(true)); |
| } |
| // BEGIN android-changed |
| return exists && isWriteableImpl(properPath(true)); |
| // END android-changed |
| } |
| |
| /** |
| * Returns the relative sort ordering of the paths for this file and the |
| * file {@code another}. The ordering is platform dependent. |
| * |
| * @param another |
| * a file to compare this file to |
| * @return an int determined by comparing the two paths. Possible values are |
| * described in the Comparable interface. |
| * @see Comparable |
| * @since Android 1.0 |
| */ |
| public int compareTo(File another) { |
| if (caseSensitive) { |
| return this.getPath().compareTo(another.getPath()); |
| } |
| return this.getPath().compareToIgnoreCase(another.getPath()); |
| } |
| |
| /** |
| * Deletes this file. Directories must be empty before they will be deleted. |
| * |
| * @return {@code true} if this file was deleted, {@code false} otherwise. |
| * @throws SecurityException |
| * if a {@code SecurityManager} is installed and it denies the |
| * request. |
| * @see java.lang.SecurityManager#checkDelete |
| * @since Android 1.0 |
| */ |
| public boolean delete() { |
| SecurityManager security = System.getSecurityManager(); |
| if (security != null) { |
| security.checkDelete(path); |
| } |
| byte[] propPath = properPath(true); |
| if ((path.length() != 0) && isDirectoryImpl(propPath)) { |
| return deleteDirImpl(propPath); |
| } |
| return deleteFileImpl(propPath); |
| } |
| |
| private native boolean deleteDirImpl(byte[] filePath); |
| |
| private native boolean deleteFileImpl(byte[] filePath); |
| |
| /** |
| * Schedules this file to be automatically deleted once the virtual machine |
| * terminates. This will only happen when the virtual machine terminates |
| * normally as described by the Java Language Specification section 12.9. |
| * |
| * @throws SecurityException |
| * if a {@code SecurityManager} is installed and it denies the |
| * request. |
| * @since Android 1.0 |
| */ |
| public void deleteOnExit() { |
| SecurityManager security = System.getSecurityManager(); |
| if (security != null) { |
| security.checkDelete(path); |
| } |
| // BEGIN android-changed |
| DeleteOnExit.getInstance().addFile(getAbsoluteName()); |
| // END android-changed |
| } |
| |
| /** |
| * Compares {@code obj} to this file and returns {@code true} if they |
| * represent the <em>same</em> object using a path specific comparison. |
| * |
| * @param obj |
| * the object to compare this file with. |
| * @return {@code true} if {@code obj} is the same as this object, |
| * {@code false} otherwise. |
| * @since Android 1.0 |
| */ |
| @Override |
| public boolean equals(Object obj) { |
| if (!(obj instanceof File)) { |
| return false; |
| } |
| if (!caseSensitive) { |
| return path.equalsIgnoreCase(((File) obj).getPath()); |
| } |
| return path.equals(((File) obj).getPath()); |
| } |
| |
| /** |
| * Returns a boolean indicating whether this file can be found on the |
| * underlying file system. |
| * |
| * @return {@code true} if this file exists, {@code false} otherwise. |
| * @throws SecurityException |
| * if a {@code SecurityManager} is installed and it denies read |
| * access to this file. |
| * @see #getPath |
| * @since Android 1.0 |
| */ |
| public boolean exists() { |
| if (path.length() == 0) { |
| return false; |
| } |
| SecurityManager security = System.getSecurityManager(); |
| if (security != null) { |
| security.checkRead(path); |
| } |
| return existsImpl(properPath(true)); |
| } |
| |
| private native boolean existsImpl(byte[] filePath); |
| |
| /** |
| * Returns the absolute path of this file. |
| * |
| * @return the absolute file path. |
| * @see java.lang.SecurityManager#checkPropertyAccess |
| * @since Android 1.0 |
| */ |
| public String getAbsolutePath() { |
| byte[] absolute = properPath(false); |
| return Util.toString(absolute); |
| } |
| |
| /** |
| * Returns a new file constructed using the absolute path of this file. |
| * |
| * @return a new file from this file's absolute path. |
| * @see java.lang.SecurityManager#checkPropertyAccess |
| * @since Android 1.0 |
| */ |
| public File getAbsoluteFile() { |
| return new File(this.getAbsolutePath()); |
| } |
| |
| /** |
| * Returns the absolute path of this file with all references resolved. An |
| * <em>absolute</em> path is one that begins at the root of the file |
| * system. The canonical path is one in which all references have been |
| * resolved. For the cases of '..' and '.', where the file system supports |
| * parent and working directory respectively, these are removed and replaced |
| * with a direct directory reference. If the file does not exist, |
| * getCanonicalPath() may not resolve any references and simply returns an |
| * absolute path name or throws an IOException. |
| * |
| * @return the canonical path of this file. |
| * @throws IOException |
| * if an I/O error occurs. |
| * @see java.lang.SecurityManager#checkPropertyAccess |
| * @since Android 1.0 |
| */ |
| public String getCanonicalPath() throws IOException { |
| byte[] result = properPath(false); |
| |
| boolean exists = false; |
| byte[] pathBytes = result; |
| do { |
| byte[] linkBytes = getLinkImpl(pathBytes); |
| if (linkBytes == pathBytes) { |
| break; |
| } |
| if (linkBytes[0] == separatorChar) { |
| pathBytes = linkBytes; |
| } else { |
| int index = pathBytes.length - 1; |
| while (pathBytes[index] != separatorChar) { |
| index--; |
| } |
| byte[] temp = new byte[index + 1 + linkBytes.length]; |
| System.arraycopy(pathBytes, 0, temp, 0, index + 1); |
| System.arraycopy(linkBytes, 0, temp, index + 1, |
| linkBytes.length); |
| pathBytes = temp; |
| } |
| exists = existsImpl(pathBytes); |
| } while (exists); |
| if (exists) { |
| result = pathBytes; |
| } |
| |
| int numSeparators = 1; |
| for (int i = 0; i < result.length; i++) { |
| if (result[i] == separatorChar) { |
| numSeparators++; |
| } |
| } |
| int sepLocations[] = new int[numSeparators]; |
| int rootLoc = 0; |
| if (separatorChar != '/') { |
| if (result[0] == '\\') { |
| rootLoc = (result.length > 1 && result[1] == '\\') ? 1 : 0; |
| } else { |
| rootLoc = 2; // skip drive i.e. c: |
| } |
| } |
| byte newResult[] = new byte[result.length + 1]; |
| int newLength = 0, lastSlash = 0, foundDots = 0; |
| sepLocations[lastSlash] = rootLoc; |
| for (int i = 0; i <= result.length; i++) { |
| if (i < rootLoc) { |
| newResult[newLength++] = result[i]; |
| } else { |
| if (i == result.length || result[i] == separatorChar) { |
| if (i == result.length && foundDots == 0) { |
| break; |
| } |
| if (foundDots == 1) { |
| /* Don't write anything, just reset and continue */ |
| foundDots = 0; |
| continue; |
| } |
| if (foundDots > 1) { |
| /* Go back N levels */ |
| lastSlash = lastSlash > (foundDots - 1) ? lastSlash |
| - (foundDots - 1) : 0; |
| newLength = sepLocations[lastSlash] + 1; |
| foundDots = 0; |
| continue; |
| } |
| sepLocations[++lastSlash] = newLength; |
| newResult[newLength++] = (byte) separatorChar; |
| continue; |
| } |
| if (result[i] == '.') { |
| foundDots++; |
| continue; |
| } |
| /* Found some dots within text, write them out */ |
| if (foundDots > 0) { |
| for (int j = 0; j < foundDots; j++) { |
| newResult[newLength++] = (byte) '.'; |
| } |
| } |
| newResult[newLength++] = result[i]; |
| foundDots = 0; |
| } |
| } |
| // remove trailing slash |
| if (newLength > (rootLoc + 1) |
| && newResult[newLength - 1] == separatorChar) { |
| newLength--; |
| } |
| newResult[newLength] = 0; |
| newResult = getCanonImpl(newResult); |
| newLength = newResult.length; |
| return Util.toString(newResult, 0, newLength); |
| } |
| |
| /** |
| * Returns a new file created using the canonical path of this file. |
| * Equivalent to {@code new File(this.getCanonicalPath())}. |
| * |
| * @return the new file constructed from this file's canonical path. |
| * @throws IOException |
| * if an I/O error occurs. |
| * @see java.lang.SecurityManager#checkPropertyAccess |
| * @since Android 1.0 |
| */ |
| public File getCanonicalFile() throws IOException { |
| return new File(getCanonicalPath()); |
| } |
| |
| private native byte[] getCanonImpl(byte[] filePath); |
| |
| /** |
| * Returns the name of the file or directory represented by this file. |
| * |
| * @return this file's name or an empty string if there is no name part in |
| * the file's path. |
| * @since Android 1.0 |
| */ |
| public String getName() { |
| int separatorIndex = path.lastIndexOf(separator); |
| return (separatorIndex < 0) ? path : path.substring(separatorIndex + 1, |
| path.length()); |
| } |
| |
| /** |
| * Returns the pathname of the parent of this file. This is the path up to |
| * but not including the last name. {@code null} is returned if there is no |
| * parent. |
| * |
| * @return this file's parent pathname or {@code null}. |
| * @since Android 1.0 |
| */ |
| public String getParent() { |
| int length = path.length(), firstInPath = 0; |
| if (separatorChar == '\\' && length > 2 && path.charAt(1) == ':') { |
| firstInPath = 2; |
| } |
| int index = path.lastIndexOf(separatorChar); |
| if (index == -1 && firstInPath > 0) { |
| index = 2; |
| } |
| if (index == -1 || path.charAt(length - 1) == separatorChar) { |
| return null; |
| } |
| if (path.indexOf(separatorChar) == index |
| && path.charAt(firstInPath) == separatorChar) { |
| return path.substring(0, index + 1); |
| } |
| return path.substring(0, index); |
| } |
| |
| /** |
| * Returns a new file made from the pathname of the parent of this file. |
| * This is the path up to but not including the last name. {@code null} is |
| * returned when there is no parent. |
| * |
| * @return a new file representing this file's parent or {@code null}. |
| * @since Android 1.0 |
| */ |
| public File getParentFile() { |
| String tempParent = getParent(); |
| if (tempParent == null) { |
| return null; |
| } |
| return new File(tempParent); |
| } |
| |
| /** |
| * Returns the path of this file. |
| * |
| * @return this file's path. |
| * @since Android 1.0 |
| */ |
| public String getPath() { |
| return path; |
| } |
| |
| /** |
| * Returns an integer hash code for the receiver. Any two objects for which |
| * {@code equals} returns {@code true} must return the same hash code. |
| * |
| * @return this files's hash value. |
| * @see #equals |
| * @since Android 1.0 |
| */ |
| @Override |
| public int hashCode() { |
| if (caseSensitive) { |
| return path.hashCode() ^ 1234321; |
| } |
| return path.toLowerCase().hashCode() ^ 1234321; |
| } |
| |
| /** |
| * Indicates if this file's pathname is absolute. Whether a pathname is |
| * absolute is platform specific. On UNIX, absolute paths must start with |
| * the character '/'; on Windows it is absolute if either it starts with |
| * '\', '/', '\\' (to represent a file server), or a letter followed by a |
| * colon. |
| * |
| * @return {@code true} if this file's pathname is absolute, {@code false} |
| * otherwise. |
| * @see #getPath |
| * @since Android 1.0 |
| */ |
| public boolean isAbsolute() { |
| // BEGIN android-changed |
| // Removing platform independent code because we're always on linux. |
| return path.length() > 0 && path.charAt(0) == separatorChar; |
| // END android-changed |
| } |
| |
| // BEGIN android-removed |
| // private native boolean isAbsoluteImpl(byte[] filePath); |
| // END android-removed |
| |
| /** |
| * Indicates if this file represents a <em>directory</em> on the |
| * underlying file system. |
| * |
| * @return {@code true} if this file is a directory, {@code false} |
| * otherwise. |
| * @throws SecurityException |
| * if a {@code SecurityManager} is installed and it denies read |
| * access to this file. |
| * @since Android 1.0 |
| */ |
| public boolean isDirectory() { |
| if (path.length() == 0) { |
| return false; |
| } |
| SecurityManager security = System.getSecurityManager(); |
| if (security != null) { |
| security.checkRead(path); |
| } |
| return isDirectoryImpl(properPath(true)); |
| } |
| |
| private native boolean isDirectoryImpl(byte[] filePath); |
| |
| /** |
| * Indicates if this file represents a <em>file</em> on the underlying |
| * file system. |
| * |
| * @return {@code true} if this file is a file, {@code false} otherwise. |
| * @throws SecurityException |
| * if a {@code SecurityManager} is installed and it denies read |
| * access to this file. |
| * @since Android 1.0 |
| */ |
| public boolean isFile() { |
| if (path.length() == 0) { |
| return false; |
| } |
| SecurityManager security = System.getSecurityManager(); |
| if (security != null) { |
| security.checkRead(path); |
| } |
| return isFileImpl(properPath(true)); |
| } |
| |
| private native boolean isFileImpl(byte[] filePath); |
| |
| /** |
| * Returns whether or not this file is a hidden file as defined by the |
| * operating system. The notion of "hidden" is system-dependent. For |
| * Unix systems (like Android) a file is considered hidden if its name |
| * starts with a ".". For Windows systems there is an explicit flag in the |
| * file system for this purpose. |
| * |
| * @return {@code true} if the file is hidden, {@code false} otherwise. |
| * @throws SecurityException |
| * if a {@code SecurityManager} is installed and it denies read |
| * access to this file. |
| * @since Android 1.0 |
| */ |
| public boolean isHidden() { |
| if (path.length() == 0) { |
| return false; |
| } |
| SecurityManager security = System.getSecurityManager(); |
| if (security != null) { |
| security.checkRead(path); |
| } |
| return isHiddenImpl(properPath(true)); |
| } |
| |
| private native boolean isHiddenImpl(byte[] filePath); |
| |
| // BEGIN android-changed |
| private native boolean isReadableImpl(byte[] filePath); |
| |
| private native boolean isWriteableImpl(byte[] filePath); |
| // END android-changed |
| |
| private native byte[] getLinkImpl(byte[] filePath); |
| |
| /** |
| * Returns the time when this file was last modified, measured in |
| * milliseconds since January 1st, 1970, midnight. |
| * |
| * @return the time when this file was last modified. |
| * @throws SecurityException |
| * if a {@code SecurityManager} is installed and it denies read |
| * access to this file. |
| * @since Android 1.0 |
| */ |
| public long lastModified() { |
| SecurityManager security = System.getSecurityManager(); |
| if (security != null) { |
| security.checkRead(path); |
| } |
| long result = lastModifiedImpl(properPath(true)); |
| /* Temporary code to handle both return cases until natives fixed */ |
| if (result == -1 || result == 0) { |
| return 0; |
| } |
| return result; |
| } |
| |
| private native long lastModifiedImpl(byte[] filePath); |
| |
| /** |
| * Sets the time this file was last modified, measured in milliseconds since |
| * January 1st, 1970, midnight. |
| * |
| * @param time |
| * the last modification time for this file. |
| * @return {@code true} if the operation is successful, {@code false} |
| * otherwise. |
| * @throws IllegalArgumentException |
| * if {@code time < 0}. |
| * @throws SecurityException |
| * if a {@code SecurityManager} is installed and it denies write |
| * access to this file. |
| * @since Android 1.0 |
| */ |
| public boolean setLastModified(long time) { |
| if (time < 0) { |
| throw new IllegalArgumentException(Msg.getString("K006a")); //$NON-NLS-1$ |
| } |
| SecurityManager security = System.getSecurityManager(); |
| if (security != null) { |
| security.checkWrite(path); |
| } |
| return (setLastModifiedImpl(properPath(true), time)); |
| } |
| |
| private native boolean setLastModifiedImpl(byte[] path, long time); |
| |
| /** |
| * Marks this file or directory to be read-only as defined by the operating |
| * system. |
| * |
| * @return {@code true} if the operation is successful, {@code false} |
| * otherwise. |
| * @throws SecurityException |
| * if a {@code SecurityManager} is installed and it denies write |
| * access to this file. |
| * @since Android 1.0 |
| */ |
| public boolean setReadOnly() { |
| SecurityManager security = System.getSecurityManager(); |
| if (security != null) { |
| security.checkWrite(path); |
| } |
| return (setReadOnlyImpl(properPath(true))); |
| } |
| |
| private native boolean setReadOnlyImpl(byte[] path); |
| |
| /** |
| * Returns the length of this file in bytes. |
| * |
| * @return the number of bytes in this file. |
| * @throws SecurityException |
| * if a {@code SecurityManager} is installed and it denies read |
| * access to this file. |
| * @since Android 1.0 |
| */ |
| public long length() { |
| SecurityManager security = System.getSecurityManager(); |
| if (security != null) { |
| security.checkRead(path); |
| } |
| return lengthImpl(properPath(true)); |
| } |
| |
| private native long lengthImpl(byte[] filePath); |
| |
| /** |
| * Returns an array of strings with the file names in the directory |
| * represented by this file. The result is {@ null} if this file is not a |
| * directory. |
| * <p> |
| * The entries {@code .} and {@code ..} representing the current and parent |
| * directory are not returned as part of the list. |
| * </p> |
| * |
| * @return an array of strings with file names or {@code null}. |
| * @throws SecurityException |
| * if a {@code SecurityManager} is installed and it denies read |
| * access to this file. |
| * @see #isDirectory |
| * @since Android 1.0 |
| */ |
| public java.lang.String[] list() { |
| SecurityManager security = System.getSecurityManager(); |
| if (security != null) { |
| security.checkRead(path); |
| } |
| if (!isDirectory()) { |
| return null; |
| } |
| byte[][] implList = listImpl(properPath(true)); |
| if (implList == null) { |
| return new String[0]; |
| } |
| String result[] = new String[implList.length]; |
| for (int index = 0; index < implList.length; index++) { |
| result[index] = Util.toString(implList[index]); |
| } |
| return result; |
| } |
| |
| /** |
| * Returns an array of files contained in the directory represented by this |
| * file. The result is {@code null} if this file is not a directory. The |
| * paths of the files in the array are absolute if the path of this file is |
| * absolute, they are relative otherwise. |
| * |
| * @return an array of files or {@code null}. |
| * @throws SecurityException |
| * if a {@code SecurityManager} is installed and it denies read |
| * access to this file. |
| * @see #list |
| * @since Android 1.0 |
| */ |
| public File[] listFiles() { |
| String[] tempNames = list(); |
| if (tempNames == null) { |
| return null; |
| } |
| int resultLength = tempNames.length; |
| File results[] = new File[resultLength]; |
| for (int i = 0; i < resultLength; i++) { |
| results[i] = new File(this, tempNames[i]); |
| } |
| return results; |
| } |
| |
| /** |
| * Gets a list of the files in the directory represented by this file. This |
| * list is then filtered through a FilenameFilter and files with matching |
| * names are returned as an array of files. Returns {@code null} if this |
| * file is not a directory. If {@code filter} is {@code null} then all |
| * filenames match. |
| * <p> |
| * The entries {@code .} and {@code ..} representing the current and parent |
| * directories are not returned as part of the list. |
| * </p> |
| * |
| * @param filter |
| * the filter to match names against, may be {@code null}. |
| * @return an array of files or {@code null}. |
| * @throws SecurityException |
| * if a {@code SecurityManager} is installed and it denies read |
| * access to this file. |
| * @see #list(FilenameFilter filter) |
| * @since Android 1.0 |
| */ |
| public File[] listFiles(FilenameFilter filter) { |
| String[] tempNames = list(filter); |
| if (tempNames == null) { |
| return null; |
| } |
| int resultLength = tempNames.length; |
| File results[] = new File[resultLength]; |
| for (int i = 0; i < resultLength; i++) { |
| results[i] = new File(this, tempNames[i]); |
| } |
| return results; |
| } |
| |
| /** |
| * Gets a list of the files in the directory represented by this file. This |
| * list is then filtered through a FileFilter and matching files are |
| * returned as an array of files. Returns {@code null} if this file is not a |
| * directory. If {@code filter} is {@code null} then all files match. |
| * <p> |
| * The entries {@code .} and {@code ..} representing the current and parent |
| * directories are not returned as part of the list. |
| * </p> |
| * |
| * @param filter |
| * the filter to match names against, may be {@code null}. |
| * @return an array of files or {@code null}. |
| * @throws SecurityException |
| * if a {@code SecurityManager} is installed and it denies read |
| * access to this file. |
| * @since Android 1.0 |
| */ |
| public File[] listFiles(FileFilter filter) { |
| SecurityManager security = System.getSecurityManager(); |
| if (security != null) { |
| security.checkRead(path); |
| } |
| if (!isDirectory()) { |
| return null; |
| } |
| byte[][] implList = listImpl(properPath(true)); |
| if (implList == null) { |
| return new File[0]; |
| } |
| List<File> tempResult = new ArrayList<File>(); |
| for (int index = 0; index < implList.length; index++) { |
| String aName = Util.toString(implList[index]); |
| File aFile = new File(this, aName); |
| if (filter == null || filter.accept(aFile)) { |
| tempResult.add(aFile); |
| } |
| } |
| return tempResult.toArray(new File[tempResult.size()]); |
| } |
| |
| /** |
| * Gets a list of the files in the directory represented by this file. This |
| * list is then filtered through a FilenameFilter and the names of files |
| * with matching names are returned as an array of strings. Returns |
| * {@code null} if this file is not a directory. If {@code filter} is |
| * {@code null} then all filenames match. |
| * <p> |
| * The entries {@code .} and {@code ..} representing the current and parent |
| * directories are not returned as part of the list. |
| * </p> |
| * |
| * @param filter |
| * the filter to match names against, may be {@code null}. |
| * @return an array of files or {@code null}. |
| * @throws SecurityException |
| * if a {@code SecurityManager} is installed and it denies read |
| * access to this file. |
| * @since Android 1.0 |
| */ |
| public java.lang.String[] list(FilenameFilter filter) { |
| SecurityManager security = System.getSecurityManager(); |
| if (security != null) { |
| security.checkRead(path); |
| } |
| if (!isDirectory()) { |
| return null; |
| } |
| byte[][] implList = listImpl(properPath(true)); |
| if (implList == null) { |
| return new String[0]; |
| } |
| java.util.Vector<String> tempResult = new java.util.Vector<String>(); |
| for (int index = 0; index < implList.length; index++) { |
| String aName = Util.toString(implList[index]); |
| if (filter == null || filter.accept(this, aName)) { |
| tempResult.addElement(aName); |
| } |
| } |
| String[] result = new String[tempResult.size()]; |
| tempResult.copyInto(result); |
| return result; |
| } |
| |
| private synchronized static native byte[][] listImpl(byte[] path); |
| |
| /** |
| * Creates the directory named by the trailing filename of this file. Does |
| * not create the complete path required to create this directory. |
| * |
| * @return {@code true} if the directory has been created, {@code false} |
| * otherwise. |
| * @throws SecurityException |
| * if a {@code SecurityManager} is installed and it denies write |
| * access for this file. |
| * @see #mkdirs |
| * @since Android 1.0 |
| */ |
| public boolean mkdir() { |
| SecurityManager security = System.getSecurityManager(); |
| if (security != null) { |
| security.checkWrite(path); |
| } |
| return mkdirImpl(properPath(true)); |
| } |
| |
| private native boolean mkdirImpl(byte[] filePath); |
| |
| /** |
| * Creates the directory named by the trailing filename of this file, |
| * including the complete directory path required to create this directory. |
| * |
| * @return {@code true} if the necessary directories have been created, |
| * {@code false} if the target directory already exists or one of |
| * the directories can not be created. |
| * @throws SecurityException |
| * if a {@code SecurityManager} is installed and it denies write |
| * access for this file. |
| * @see #mkdir |
| * @since Android 1.0 |
| */ |
| public boolean mkdirs() { |
| /* If the terminal directory already exists, answer false */ |
| if (exists()) { |
| return false; |
| } |
| |
| /* If the receiver can be created, answer true */ |
| if (mkdir()) { |
| return true; |
| } |
| |
| String parentDir = getParent(); |
| /* If there is no parent and we were not created, answer false */ |
| if (parentDir == null) { |
| return false; |
| } |
| |
| /* Otherwise, try to create a parent directory and then this directory */ |
| return (new File(parentDir).mkdirs() && mkdir()); |
| } |
| |
| /** |
| * Creates a new, empty file on the file system according to the path |
| * information stored in this file. |
| * |
| * @return {@code true} if the file has been created, {@code false} if it |
| * already exists. |
| * @throws IOException |
| * if an I/O error occurs or the directory does not exist where |
| * the file should have been created. |
| * @throws SecurityException |
| * if a {@code SecurityManager} is installed and it denies write |
| * access for this file. |
| * @since Android 1.0 |
| */ |
| public boolean createNewFile() throws IOException { |
| SecurityManager security = System.getSecurityManager(); |
| if (security != null) { |
| security.checkWrite(path); |
| } |
| if (0 == path.length()) { |
| throw new IOException(Msg.getString("KA012")); //$NON-NLS-1$ |
| } |
| int result = newFileImpl(properPath(true)); |
| switch (result) { |
| case 0: |
| return true; |
| case 1: |
| return false; |
| // BEGIN android-changed |
| default: { |
| // Try to provide a reasonable explanation. |
| String msg = null; |
| try { |
| File parent = getAbsoluteFile().getParentFile(); |
| if (parent == null) { |
| /* |
| * This shouldn't happen, unless the caller |
| * tried to create "/". We just use the |
| * generic message for this case. |
| */ |
| } else if (! parent.exists()) { |
| msg = "Parent directory of file does not exist"; |
| } else if (! parent.isDirectory()) { |
| msg = "Parent of file is not a directory"; |
| } else if (! parent.canWrite()) { |
| msg = "Parent directory of file is not writable"; |
| } |
| } catch (RuntimeException ex) { |
| /* |
| * Ignore the exception, and just fall through to |
| * use a generic message. |
| */ |
| } |
| |
| if (msg == null) { |
| msg = "Cannot create"; |
| } |
| throw new IOException(msg + ": " + path); //$NON-NLS-1$ |
| } |
| // END android-changed |
| } |
| } |
| |
| private native int newFileImpl(byte[] filePath); |
| |
| /** |
| * Creates an empty temporary file using the given prefix and suffix as part |
| * of the file name. If suffix is null, {@code .tmp} is used. This method |
| * is a convenience method that calls {@link #createTempFile(String, String, |
| * File)} with the third argument being {@code null}. |
| * |
| * @param prefix |
| * the prefix to the temp file name. |
| * @param suffix |
| * the suffix to the temp file name. |
| * @return the temporary file. |
| * @throws IOException |
| * if an error occurs when writing the file. |
| * @since Android 1.0 |
| */ |
| public static File createTempFile(String prefix, String suffix) |
| throws IOException { |
| return createTempFile(prefix, suffix, null); |
| } |
| |
| /** |
| * Creates an empty temporary file in the given directory using the given |
| * prefix and suffix as part of the file name. |
| * |
| * @param prefix |
| * the prefix to the temp file name. |
| * @param suffix |
| * the suffix to the temp file name. |
| * @param directory |
| * the location to which the temp file is to be written, or |
| * {@code null} for the default location for temporary files, |
| * which is taken from the "java.io.tmpdir" system property. It |
| * may be necessary to set this property to an existing, writable |
| * directory for this method to work properly. |
| * @return the temporary file. |
| * @throws IllegalArgumentException |
| * if the length of {@code prefix} is less than 3. |
| * @throws IOException |
| * if an error occurs when writing the file. |
| * @since Android 1.0 |
| */ |
| public static File createTempFile(String prefix, String suffix, |
| File directory) throws IOException { |
| // Force a prefix null check first |
| if (prefix.length() < 3) { |
| throw new IllegalArgumentException(Msg.getString("K006b")); //$NON-NLS-1$ |
| } |
| String newSuffix = suffix == null ? ".tmp" : suffix; //$NON-NLS-1$ |
| String tmpDir = "."; //$NON-NLS-1$ |
| tmpDir = AccessController.doPrivileged(new PriviAction<String>( |
| "java.io.tmpdir", ".")); //$NON-NLS-1$//$NON-NLS-2$ |
| File result, tmpDirFile = directory == null ? new File(tmpDir) |
| : directory; |
| do { |
| result = genTempFile(prefix, newSuffix, tmpDirFile); |
| } while (!result.createNewFile()); |
| return result; |
| } |
| |
| private static File genTempFile(String prefix, String suffix, File directory) { |
| if (counter == 0) { |
| int newInt = new java.util.Random().nextInt(); |
| counter = ((newInt / 65535) & 0xFFFF) + 0x2710; |
| } |
| StringBuilder newName = new StringBuilder(); |
| newName.append(prefix); |
| newName.append(counter++); |
| newName.append(suffix); |
| return new File(directory, newName.toString()); |
| } |
| |
| // BEGIN android-changed |
| // Removing platform independent code because we're always on linux. |
| /** |
| * Returns a string representing the proper path for this file. If this file |
| * path is absolute, the user.dir property is not prepended, otherwise it |
| * is. |
| * |
| * @param internal |
| * is user.dir internal. |
| * @return the proper path. |
| */ |
| byte[] properPath(boolean internal) { |
| if (properPath != null) { |
| return properPath; |
| } |
| if(path.length() > 0 && path.charAt(0) == separatorChar) { |
| return properPath = Util.getBytes(path); |
| } |
| // Check security by getting user.dir when the path is not absolute |
| String userdir; |
| if (internal) { |
| userdir = AccessController.doPrivileged(new PriviAction<String>( |
| "user.dir")); //$NON-NLS-1$ |
| } else { |
| userdir = System.getProperty("user.dir"); //$NON-NLS-1$ |
| } |
| if (path.length() == 0) { |
| return properPath = Util.getBytes(userdir); |
| } |
| int length = userdir.length(); |
| if (length > 0 && userdir.charAt(length - 1) == separatorChar) { |
| return properPath = Util.getBytes(userdir + path); |
| } |
| return properPath = Util.getBytes(userdir + separator + path); |
| } |
| // END android-changed |
| |
| // BEGIN android-removed |
| // private static native byte[] properPathImpl(byte[] path); |
| // END android-removed |
| |
| /** |
| * Renames this file to the name represented by the {@code dest} file. This |
| * works for both normal files and directories. |
| * |
| * @param dest |
| * the file containing the new name. |
| * @return {@code true} if the File was renamed, {@code false} otherwise. |
| * @throws SecurityException |
| * if a {@code SecurityManager} is installed and it denies write |
| * access for this file or the {@code dest} file. |
| * @since Android 1.0 |
| */ |
| public boolean renameTo(java.io.File dest) { |
| SecurityManager security = System.getSecurityManager(); |
| if (security != null) { |
| security.checkWrite(path); |
| security.checkWrite(dest.path); |
| } |
| return renameToImpl(properPath(true), dest.properPath(true)); |
| } |
| |
| private native boolean renameToImpl(byte[] pathExist, byte[] pathNew); |
| |
| /** |
| * Returns a string containing a concise, human-readable description of this |
| * file. |
| * |
| * @return a printable representation of this file. |
| * @since Android 1.0 |
| */ |
| @Override |
| public String toString() { |
| return path; |
| } |
| |
| /** |
| * Returns a Uniform Resource Identifier for this file. The URI is system |
| * dependent and may not be transferable between different operating / file |
| * systems. |
| * |
| * @return an URI for this file. |
| * @since Android 1.0 |
| */ |
| public URI toURI() { |
| String name = getAbsoluteName(); |
| try { |
| if (!name.startsWith("/")) { //$NON-NLS-1$ |
| // start with sep. |
| return new URI("file", null, //$NON-NLS-1$ |
| new StringBuilder(name.length() + 1).append('/') |
| .append(name).toString(), null, null); |
| } else if (name.startsWith("//")) { //$NON-NLS-1$ |
| return new URI("file", name, null); // UNC path //$NON-NLS-1$ |
| } |
| return new URI("file", null, name, null, null); //$NON-NLS-1$ |
| } catch (URISyntaxException e) { |
| // this should never happen |
| return null; |
| } |
| } |
| |
| /** |
| * Returns a Uniform Resource Locator for this file. The URL is system |
| * dependent and may not be transferable between different operating / file |
| * systems. |
| * |
| * @return an URL for this file. |
| * @throws java.net.MalformedURLException |
| * if the path cannot be transformed into an URL. |
| * @since Android 1.0 |
| */ |
| public URL toURL() throws java.net.MalformedURLException { |
| String name = getAbsoluteName(); |
| if (!name.startsWith("/")) { //$NON-NLS-1$ |
| // start with sep. |
| return new URL("file", "", -1, new StringBuilder(name.length() + 1) //$NON-NLS-1$ //$NON-NLS-2$ |
| .append('/').append(name).toString(), null); |
| } else if (name.startsWith("//")) { //$NON-NLS-1$ |
| return new URL("file:" + name); // UNC path //$NON-NLS-1$ |
| } |
| return new URL("file", "", -1, name, null); //$NON-NLS-1$ //$NON-NLS-2$ |
| } |
| |
| private String getAbsoluteName() { |
| File f = getAbsoluteFile(); |
| String name = f.getPath(); |
| |
| if (f.isDirectory() && name.charAt(name.length() - 1) != separatorChar) { |
| // Directories must end with a slash |
| name = new StringBuilder(name.length() + 1).append(name) |
| .append('/').toString(); |
| } |
| if (separatorChar != '/') { // Must convert slashes. |
| name = name.replace(separatorChar, '/'); |
| } |
| return name; |
| } |
| |
| private void writeObject(ObjectOutputStream stream) throws IOException { |
| stream.defaultWriteObject(); |
| stream.writeChar(separatorChar); |
| |
| } |
| |
| private void readObject(ObjectInputStream stream) throws IOException, |
| ClassNotFoundException { |
| stream.defaultReadObject(); |
| char inSeparator = stream.readChar(); |
| path = path.replace(inSeparator, separatorChar); |
| } |
| } |
| |
| // BEGIN android-added |
| /** |
| * Implements the actual DeleteOnExit mechanism. Is registered as a shutdown |
| * hook in the Runtime, once it is actually being used. |
| */ |
| class DeleteOnExit extends Thread { |
| |
| /** |
| * Our singleton instance. |
| */ |
| private static DeleteOnExit instance; |
| |
| /** |
| * Our list of files scheduled for deletion. |
| */ |
| private ArrayList<String> files = new ArrayList<String>(); |
| |
| /** |
| * Returns our singleton instance, creating it if necessary. |
| */ |
| public static synchronized DeleteOnExit getInstance() { |
| if (instance == null) { |
| instance = new DeleteOnExit(); |
| Runtime.getRuntime().addShutdownHook(instance); |
| } |
| |
| return instance; |
| } |
| |
| /** |
| * Schedules a file for deletion. |
| * |
| * @param filename The file to delete. |
| */ |
| public void addFile(String filename) { |
| synchronized(files) { |
| if (!files.contains(filename)) { |
| files.add(filename); |
| } |
| } |
| } |
| |
| /** |
| * Does the actual work. Note we (a) first sort the files lexicographically |
| * and then (b) delete them in reverse order. This is to make sure files |
| * get deleted before their parent directories. |
| */ |
| @Override |
| public void run() { |
| Collections.sort(files); |
| for (int i = files.size() - 1; i >= 0; i--) { |
| new File(files.get(i)).delete(); |
| } |
| } |
| } |
| // END android-added |
