/*
* Copyright (C) 2012 The Android Open Source Project
*
* Licensed 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 com.motorola.studio.android.common.utilities;
import static com.motorola.studio.android.common.log.StudioLogger.warn;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.LineNumberReader;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.math.BigInteger;
import java.nio.channels.FileChannel;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Enumeration;
import java.util.LinkedList;
import java.util.List;
import java.util.StringTokenizer;
import java.util.zip.CRC32;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.SubMonitor;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.text.Document;
import org.eclipse.jface.text.IDocument;
import org.eclipse.osgi.util.NLS;
import org.eclipse.ui.editors.text.TextFileDocumentProvider;
import com.motorola.studio.android.common.CommonPlugin;
import com.motorola.studio.android.common.log.StudioLogger;
import com.motorola.studio.android.common.utilities.i18n.UtilitiesNLS;
/**
* DESCRIPTION: This class provides utility methods to handle files, like
* copying and deleting directories sub-trees.
*
* USAGE: See public methods
*/
public class FileUtil
{
public static final int OS_WINDOWS = 0;
public static final int OS_LINUX = 1;
public static final char[] MAC_SPECIAL_CHAR =
{
'\\', ' ', '\'', '"', '!', '@', '$', '&', '*', '(', ')', '=', '`', '[', ']', '{', '}',
'^', '<', '>', ':', ';', '?', '|'
};
public static final char[] LINUX_SPECIAL_CHAR =
{
'\\', ' ', '\'', '"', '!', '$', '&', '*', '(', ')', '=', '`', '[', ']', '{', '}', '^',
'<', '>', ':', ';', '?', '|'
};
public static final char ESCAPE_CHAR = '\\';
private static final int BUFFER_SIZE = 1024;
/**
* Copy full list of contents from a directory to another. The source
* directory is not created within the target one.
*
* @param fromDir
* Source directory.
* @param toDir
* Target directory.
*
* @param IOException if I/O occurs
*/
public static void copyDir(File fromDir, File toDir) throws IOException
{
if ((fromDir != null) && fromDir.isDirectory() && fromDir.canRead() && (toDir != null)
&& toDir.isDirectory() && toDir.canWrite())
{
for (File child : fromDir.listFiles())
{
if (child.isFile())
{
copyFile(child, new File(toDir, child.getName()));
}
else
{
// create directory and copy its children recursively
File newDir = new File(toDir.getAbsolutePath(), child.getName());
newDir.mkdir();
copyDir(child, newDir);
}
}
StudioLogger.info("The directory " + fromDir.getName() + " was successfully copied to " //$NON-NLS-1$ //$NON-NLS-2$
+ toDir.getName() + "."); //$NON-NLS-1$
}
else
{
//error detected
String errorMessage = ""; //$NON-NLS-1$
if (fromDir == null)
{
errorMessage = "Null pointer for source directory."; //$NON-NLS-1$
}
else
{
if (!fromDir.isDirectory())
{
errorMessage = fromDir.getName() + " is not a directory."; //$NON-NLS-1$
}
else
{
if (!fromDir.canRead())
{
errorMessage = "Cannot read from " + fromDir.getName() + "."; //$NON-NLS-1$ //$NON-NLS-2$
}
else
{
if (toDir == null)
{
errorMessage = "Null pointer for destination directory."; //$NON-NLS-1$
}
else
{
if (!toDir.isDirectory())
{
errorMessage = toDir.getName() + " is not a directory."; //$NON-NLS-1$
}
else
{
if (!toDir.canWrite())
{
errorMessage = "Cannot write to" + toDir.getName() + "."; //$NON-NLS-1$ //$NON-NLS-2$
}
}
}
}
}
}
StudioLogger.error(errorMessage);
throw new IOException("Error copying directory: " + errorMessage); //$NON-NLS-1$
}
}
/**
* Copies the source file to the given target.
*
* @param source -
* the absolute path of the source file.
* @param target -
* the absolute path of the target file.
*/
public static void copyFile(File source, File target) throws IOException
{
copyFile(source.getAbsolutePath(), target.getAbsolutePath());
}
/**
* Copies the source file to the given target.
*
* @param source -
* the absolute path of the source file.
* @param target -
* the absolute path of the target file.
*/
private static void copyFile(String source, String target) throws IOException
{
FileChannel sourceFileChannel = null;
FileChannel targetFileChannel = null;
FileInputStream sourceFileInStream = null;
FileOutputStream targetFileOutStream = null;
try
{
sourceFileInStream = new FileInputStream(source);
sourceFileChannel = sourceFileInStream.getChannel();
targetFileOutStream = new FileOutputStream(target);
targetFileChannel = targetFileOutStream.getChannel();
targetFileChannel.transferFrom(sourceFileChannel, 0, sourceFileChannel.size());
StudioLogger.info("The file " + source + " was successfully copied to " + target + "."); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
}
catch (IOException e)
{
StudioLogger.error("Error copying file" + source + "to " + target + "."); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
throw e;
}
finally
{
try
{
if (sourceFileChannel != null)
{
sourceFileChannel.close();
}
}
catch (IOException e)
{
StudioLogger.error("Error closing file " + source + "."); //$NON-NLS-1$ //$NON-NLS-2$
throw e;
}
try
{
if (targetFileChannel != null)
{
targetFileChannel.close();
}
}
catch (IOException e)
{
StudioLogger.error("Error closing file" + target + "."); //$NON-NLS-1$ //$NON-NLS-2$
throw e;
}
try
{
if (sourceFileInStream != null)
{
sourceFileInStream.close();
}
}
catch (IOException e)
{
StudioLogger.error("Error closing file" + source + "."); //$NON-NLS-1$ //$NON-NLS-2$
throw e;
}
try
{
if (targetFileOutStream != null)
{
targetFileOutStream.close();
}
}
catch (IOException e)
{
StudioLogger.error("Error closing file" + target + "."); //$NON-NLS-1$ //$NON-NLS-2$
throw e;
}
}
}
/**
* This method deletes the directory, all files and all subdirectories under
* it. If a deletion fails, the method stops attempting to delete and
* returns false.
*
* @param directory
* The directory to be deleted
* @return Returns true if all deletions were successful. If the directory
* doesn't exist returns false.
* @throws IOException
* When the parameter isn't a directory
*/
public static boolean deleteDirRecursively(File directory) throws IOException
{
String dirName = ""; //$NON-NLS-1$
boolean success = true;
if (directory.exists())
{
if (directory.isDirectory())
{
dirName = directory.getName();
File[] children = directory.listFiles();
for (File element : children)
{
if (element.isFile())
{
success = success && element.delete();
}
else
{
success = success && deleteDirRecursively(element);
}
}
success = success && directory.delete();
}
else
{
String errorMessage = directory.getName() + " is not a diretory."; //$NON-NLS-1$
StudioLogger.error(errorMessage);
throw new IOException(errorMessage);
}
}
else
{
String errorMessage = "The directory does not exist."; //$NON-NLS-1$
StudioLogger.error(errorMessage);
success = false;
throw new IOException(errorMessage);
}
if ((success) && (!dirName.equals(""))) //$NON-NLS-1$
{
StudioLogger.info("The directory " + dirName + "was successfully deleted."); //$NON-NLS-1$ //$NON-NLS-2$
}
return success;
}
/**
* Delete a single file from the filesystem.
*
* @param fileToDelete
* A <code>File</code> object representing the file to be
* deleted.
* @throws IOException
* if any problem occurs deleting the file.
*/
public static void deleteFile(File fileToDelete) throws IOException
{
if ((fileToDelete != null) && fileToDelete.exists() && fileToDelete.isFile()
&& fileToDelete.canWrite())
{
fileToDelete.delete();
StudioLogger.info("The file " + fileToDelete.getName() + "was successfully deleted."); //$NON-NLS-1$ //$NON-NLS-2$
}
else
{
String errorMessage = ""; //$NON-NLS-1$
if (fileToDelete == null)
{
errorMessage = "Null pointer for file to delete."; //$NON-NLS-1$
}
else
{
if (!fileToDelete.exists())
{
errorMessage = "The file " + fileToDelete.getName() + " does not exist."; //$NON-NLS-1$ //$NON-NLS-2$
}
else
{
if (!fileToDelete.isFile())
{
errorMessage = fileToDelete.getName() + " is not a file."; //$NON-NLS-1$
}
else
{
if (!fileToDelete.canWrite())
{
errorMessage = "Cannot write to " + fileToDelete.getName(); //$NON-NLS-1$
}
}
}
}
StudioLogger.error(errorMessage);
throw new IOException("Cannot delete file: " + errorMessage); //$NON-NLS-1$
}
}
/**
* Delete a list of files from the filesystem.
*
* @param filesToDelete
* A list of <code>File</code> objects representing the files
* to be deleted.
* @throws IOException
* if any problem occurs deleting the files.
*/
public static void deleteFilesOnList(List<File> filesToDelete) throws IOException
{
for (File element : filesToDelete)
{
if (element.exists())
{
deleteFile((element));
}
}
}
/**
* Return the File Size in Bytes.
*
* @param root The root File, it can be a directory
* @return The size of the file in bytes
* @throws IOException
*/
public static int getFileSize(File root) throws IOException
{
int size = 0;
if (root.isDirectory())
{
for (File child : root.listFiles())
{
size += FileUtil.getFileSize(child);
}
}
else if (root.isFile())
{
FileInputStream fis = new FileInputStream(root);
int available;
try
{
available = fis.available();
}
finally
{
try
{
fis.close();
}
catch (IOException e)
{
//Do thing.
}
}
size = available;
}
return size;
}
/**
* getExtension(String fileName)
*
* @param fileName
* returns the extension of a given file. "extension" here means
* the final part of the string after the last dot.
*
* @return String containing the extension
*/
public static String getExtension(String fileName)
{
if (fileName != null)
{
int i = fileName.lastIndexOf(".") + 1; //$NON-NLS-1$
return (i == 0) ? "" : fileName.substring(i); //$NON-NLS-1$
}
else
{
StudioLogger.error("The file " + fileName + " does not exist."); //$NON-NLS-1$ //$NON-NLS-2$
return null;
}
}
/**
* Get the list of all File objects that compose the path to the given File
* object
*
* @param aFile
* the file whose path must be retrieved.
* @return a List with all the File objects that compose the path to the
* given File object.
*/
public static List<File> getFilesComposingPath(File aFile)
{
List<File> fileList;
if (aFile == null)
{
fileList = new ArrayList<File>();
}
else
{
fileList = getFilesComposingPath(aFile.getParentFile());
fileList.add(aFile);
}
return fileList;
}
/**
* Retrieve the relative filename to access a targetFile from a homeFile
* parent directory. Notice that to actualy use a relative File object you
* must use the following new File(homeDir, relativeFilename) because using
* only new File(relativeFilename) would give you a file whose directory is
* the one set in the "user.dir" property.
*
* @param homeDir
* the directory from where you want to access the targetFile
* @param targetFile
* the absolute file or dir that you want to access via relative
* filename from the homeFile
* @return the relative filename that describes the location of the
* targetFile referenced from the homeFile dir
* @throws IOException
*/
public static String getRelativeFilename(File homeDir, File targetFile) throws IOException
{
StringBuffer relativePath = new StringBuffer();
List<File> homeDirList = getFilesComposingPath(getCanonicalFile(homeDir));
List<File> targetDirList = getFilesComposingPath(getCanonicalFile(targetFile));
if (homeDirList.size() == 0)
{
StudioLogger.info("Home Dir has no parent."); //$NON-NLS-1$
}
if (targetDirList.size() == 0)
{
StudioLogger.info("Target Dir has no parent."); //$NON-NLS-1$
}
// get the index of the last common directory between sourceFile and
// targetFile
int commonIndex = -1;
for (int i = 0; (i < homeDirList.size()) && (i < targetDirList.size()); i++)
{
File aHomeDir = homeDirList.get(i);
File aTargetDir = targetDirList.get(i);
if (aHomeDir.equals(aTargetDir))
{
commonIndex = i;
}
else
{
break;
}
}
// return from all remaining directories of the homeFile
for (int i = commonIndex + 1; i < homeDirList.size(); i++)
{
relativePath.append(".."); //$NON-NLS-1$
relativePath.append(File.separatorChar);
}
// enter into all directories of the target file
// stops when reachs the file name and extension
for (int i = commonIndex + 1; i < targetDirList.size(); i++)
{
File targetDir = targetDirList.get(i);
relativePath.append(targetDir.getName());
if (i != (targetDirList.size() - 1))
{
relativePath.append(File.separatorChar);
}
}
return relativePath.toString();
}
/**
* Return a list of file absolute paths under "baseDir" and under its subdirectories,
* recursively.
*
* @param baseDirToList
* A string that represents the BaseDir to initial search.
* @return A List of filepaths of files under the "baseDir".
* @throws IOException
* If the "baseDir" can not be read.
*/
public static List<String> listFilesRecursively(String baseDirToList) throws IOException
{
File baseDirToListFiles = new File(baseDirToList);
List<String> listOfFiles = listFilesRecursively(baseDirToListFiles);
return listOfFiles;
}
/**
* Return a list of file absolute paths under "baseDir" and under its subdirectories,
* recursively.
*
* @param baseDirToList
* A file object that represents the "baseDir".
* @return A List of filepaths of files under the "baseDir".
* @throws IOException
* If the "baseDir" can not be read.
*/
public static List<String> listFilesRecursively(File baseDirToList) throws IOException
{
List<String> listOfFiles = new ArrayList<String>();
if (baseDirToList.exists() && baseDirToList.isDirectory() && baseDirToList.canRead())
{
File[] children = baseDirToList.listFiles();
for (File child : children)
{
if (child.isFile())
{
listOfFiles.add(child.getAbsolutePath());
}
else
{
List<String> temporaryList = listFilesRecursively(child);
listOfFiles.addAll(temporaryList);
}
}
}
else
{
String errorMessage = ""; //$NON-NLS-1$
if (!baseDirToList.exists())
{
errorMessage = "The base dir does not exist."; //$NON-NLS-1$
}
else
{
if (!baseDirToList.isDirectory())
{
errorMessage = baseDirToList.getName() + "is not a directory."; //$NON-NLS-1$
}
else
{
if (!baseDirToList.canRead())
{
errorMessage = "Cannot fread from " + baseDirToList.getName() + "."; //$NON-NLS-1$ //$NON-NLS-2$
}
}
}
StudioLogger.error(errorMessage);
throw new IOException("Error listing files: " + errorMessage); //$NON-NLS-1$
}
return listOfFiles;
}
/**
* Calculate the canonical (an absolute filename without "\.\" and "\..\")
* that describe the file described by the absoluteFilename.
* @param absoluteFilename a file name that describe the full path of the file to use.
* @return the canonical File objecta
*/
public static File getCanonicalFile(String absoluteFilename)
{
return getCanonicalFile(new File(absoluteFilename));
}
/**
* Calculate the canonical (an absolute filename without "\.\" and "\..\")
* that describe the file described by the given location and filename.
* @param location the directory of the file to be used
* @param filename (or a relative filename) of the file to be used
* @return the canonical File objecta
*/
public static File getCanonicalFile(File location, String filename)
{
return getCanonicalFile(new File(location, filename));
}
/**
* Calculate the canonical (an absolute filename without "\.\" and "\..\")
* that describe the given file.
* @param aFile the file whose cannonical path will be calculated
* @return the canonical File objecta
*/
public static File getCanonicalFile(File aFile)
{
File f = null;
try
{
f = aFile.getCanonicalFile();
}
catch (IOException e)
{
// this should never happens
StudioLogger.error(FileUtil.class, "FileUtil.getCanonicalFile: IOException e", e); //$NON-NLS-1$
// since it's not possible to read from filesystem, return a File using String
String filename = aFile.getAbsolutePath();
StringTokenizer st = new StringTokenizer(filename, File.separator);
StringBuffer sb = new StringBuffer();
while (st.hasMoreTokens())
{
String token = (String) st.nextElement();
if (token.equals("..")) //$NON-NLS-1$
{
int lastDirIndex = sb.lastIndexOf(File.separator);
// do not go back currently on the root directory
if (lastDirIndex > 2)
{
sb.delete(lastDirIndex, sb.length());
}
}
else if (!token.equals(".")) //$NON-NLS-1$
{
if (sb.length() > 0)
{
sb.append(File.separator);
}
sb.append(token);
if (token.endsWith(":")) //$NON-NLS-1$
{
sb.append(File.separator);
}
}
}
f = new File(sb.toString());
}
return f;
}
/**
* Returns which is the OS.
* @return
* a code corresponding to the proper OS
*/
public static int getOS()
{
int result = -1;
String osName = System.getProperty("os.name").toLowerCase(); //$NON-NLS-1$
if (osName.indexOf("linux") > -1) //$NON-NLS-1$
{
result = OS_LINUX;
}
else if (osName.indexOf("windows") > -1) //$NON-NLS-1$
{
result = OS_WINDOWS;
}
return result;
}
/**
* Returns true if the OS is windows
* @return true if the OS is windows
*/
public static boolean isWindows()
{
return getOS() == OS_WINDOWS;
}
/**
* Opens the stream;
*
* @param stream File Stream
*
* @return StringBuffer with the file content
*
* @throws IOException
*/
public static StringBuffer openFile(InputStream stream) throws IOException
{
InputStreamReader streamReader = null;
StringBuffer fileBuffer = new StringBuffer();
BufferedReader reader = null;
try
{
streamReader = new InputStreamReader(stream);
reader = new BufferedReader(streamReader);
char[] buffer = new char[1024];
int line = reader.read(buffer);
while (line > 0)
{
fileBuffer.append(buffer, 0, line);
line = reader.read(buffer);
}
}
finally
{
if (streamReader != null)
{
try
{
streamReader.close();
}
catch (Exception e)
{
//Do nothing.
}
}
if (reader != null)
{
try
{
reader.close();
}
catch (Exception e)
{
//Do nothing.
}
}
}
return fileBuffer;
}
/**
* Reads a file into a string array
*
* @param filename The file name
* @return The file contents as a string array
* @throws IOException
*/
public static String[] readFileAsArray(String filename) throws IOException
{
LinkedList<String> file = new LinkedList<String>();
String[] lines = new String[0];
String line;
FileReader reader = null;
LineNumberReader lineReader = null;
try
{
reader = new FileReader(filename);
lineReader = new LineNumberReader(reader);
while ((line = lineReader.readLine()) != null)
{
file.add(line);
}
lines = new String[file.size()];
lines = file.toArray(lines);
}
finally
{
try
{
lineReader.close();
reader.close();
}
catch (Exception e)
{
// Do nothing
}
}
return lines;
}
/**
* Reads a file on workspace and returns an IDocument object with its content
*
* @param file The file to read
* @return The IDocument object containing the file contents
*
* @throws CoreException
*/
public static IDocument readFile(IFile file) throws CoreException
{
if (!canRead(file))
{
String errMsg = NLS.bind(UtilitiesNLS.EXC_FileUtil_TheFileCannotBeRead, file.getName());
IStatus status = new Status(IStatus.ERROR, CommonPlugin.PLUGIN_ID, errMsg);
throw new CoreException(status);
}
TextFileDocumentProvider documentProvider = new TextFileDocumentProvider();
IDocument document = new Document();
documentProvider.connect(file);
document = documentProvider.getDocument(file);
documentProvider.disconnect(file);
return document;
}
/**
* Saves the content of an IDocument object to a file on workspace
* @param file The file
* @param document The IDocument object
* @param encoding The file encoding
* @param overwrite If the file can be overwritten
* @throws CoreException
*/
public static void saveFile(IFile file, IDocument document, String encoding, boolean overwrite)
throws CoreException
{
if (file.exists() && !overwrite)
{
String errMsg =
NLS.bind(UtilitiesNLS.EXC_FileUtil_CannotOverwriteTheFile, file.getName());
IStatus status = new Status(IStatus.ERROR, CommonPlugin.PLUGIN_ID, errMsg);
throw new CoreException(status);
}
if (!canWrite(file))
{
String errMsg = NLS.bind(UtilitiesNLS.EXC_FileUtil_ErrorWritingTheFile, file.getName());
IStatus status = new Status(IStatus.ERROR, CommonPlugin.PLUGIN_ID, errMsg);
throw new CoreException(status);
}
ByteArrayInputStream bais = null;
try
{
bais = new ByteArrayInputStream(document.get().getBytes(encoding));
file.setCharset(encoding, new NullProgressMonitor());
file.setContents(bais, true, false, new NullProgressMonitor());
}
catch (UnsupportedEncodingException e1)
{
String errMsg =
NLS.bind(UtilitiesNLS.EXC_FileUtil_ErrorSettingTheFileEncoding, file.getName());
IStatus status = new Status(IStatus.ERROR, CommonPlugin.PLUGIN_ID, errMsg);
throw new CoreException(status);
}
finally
{
if (bais != null)
{
try
{
bais.close();
}
catch (IOException e)
{
// Do nothing.
}
}
}
}
/**
* Checks if a file can be read
*
* @param file The file to be checked
* @return true if the file can be read or false otherwise
*/
public static boolean canRead(IFile file)
{
boolean canRead = true;
InputStream is = null;
try
{
if (file.exists())
{
file.refreshLocal(IResource.DEPTH_ZERO, new NullProgressMonitor());
is = file.getContents();
is.read();
}
}
catch (CoreException e)
{
canRead = false;
}
catch (IOException e)
{
canRead = false;
}
finally
{
if (is != null)
{
try
{
is.close();
}
catch (IOException e)
{
// do nothing
}
}
}
return canRead;
}
/**
* Checks if a file can be written
*
* @param file the file to be checked
* @return true if the file can be written or false otherwise
*/
public static boolean canWrite(IFile file)
{
boolean canWrite = true;
if (file.exists() && canRead(file))
{
canWrite = !file.isReadOnly();
}
else
{
IFolder parent = (IFolder) file.getParent();
if (!parent.isAccessible())
{
canWrite = false;
}
else
{
try
{
if (parent.members() == null)
{
canWrite = false;
}
else
{
NullProgressMonitor nullProgressMonitor = new NullProgressMonitor();
file.create(null, true, nullProgressMonitor);
file.refreshLocal(IResource.DEPTH_ZERO, nullProgressMonitor);
file.delete(true, nullProgressMonitor);
}
}
catch (CoreException e)
{
canWrite = false;
}
}
}
return canWrite;
}
/**
* Checks if a File object can be read
*
* @param file the File object
*
* @return true if the File object can be read or false otherwise
*/
public static boolean canRead(File file)
{
boolean canRead = false;
if ((file != null) && file.exists())
{
FileInputStream fis = null;
try
{
if (file.isFile())
{
fis = new FileInputStream(file);
fis.read();
canRead = true;
}
else
{
String[] children = file.list();
if (children != null)
{
canRead = true;
}
}
}
catch (Exception e)
{
// Do nothing. canRead is false already
}
finally
{
try
{
if (fis != null)
{
fis.close();
}
}
catch (IOException e)
{
// Do nothing
}
}
}
return canRead;
}
/**
* Checks if a File object can be written
*
* @param file the File object
*
* @return true if the File object can be written or false otherwise
*/
public static boolean canWrite(File file)
{
boolean canWrite = false;
if (file != null)
{
FileOutputStream fos = null;
try
{
if (!file.exists())
{
canWrite = file.createNewFile();
if (canWrite)
{
file.delete();
}
}
else if (file.isDirectory())
{
File tempFile = File.createTempFile("StudioForAndroidFSChecking", null, file); //$NON-NLS-1$
if (tempFile.exists())
{
canWrite = true;
tempFile.delete();
}
}
else if (file.isFile())
{
fos = new FileOutputStream(file);
fos.getFD();
canWrite = true;
}
}
catch (Exception e)
{
// Do nothing. canWrite is false already
}
finally
{
if (fos != null)
{
try
{
fos.close();
}
catch (IOException e)
{
// Do nothing
}
}
}
}
return canWrite;
}
/**
* Unpack a zip file.
*
* @param file the file
* @param destination the destination path or null to unpack at the same directory of file
* @return true if unpacked, false otherwise
*/
public static boolean unpackZipFile(File file, String destination, IProgressMonitor monitor)
{
SubMonitor subMonitor = SubMonitor.convert(monitor);
ZipFile zipFile = null;
String extractDestination = destination != null ? destination : file.getParent();
if (!extractDestination.endsWith(File.separator))
{
extractDestination += File.separator;
}
boolean unziped = true;
try
{
zipFile = new ZipFile(file);
}
catch (Throwable e)
{
unziped = false;
StudioLogger.error(FileUtil.class, "Error extracting file: " + file.getAbsolutePath() //$NON-NLS-1$
+ " to " + extractDestination, e); //$NON-NLS-1$
}
if (zipFile != null)
{
Enumeration<? extends ZipEntry> entries = zipFile.entries();
subMonitor.beginTask("Extracting files", Collections.list(entries).size()); //$NON-NLS-1$
entries = zipFile.entries();
InputStream input = null;
OutputStream output = null;
while (entries.hasMoreElements())
{
try
{
ZipEntry entry = entries.nextElement();
File newFile = new File(extractDestination + entry.getName());
if (entry.isDirectory())
{
newFile.mkdirs();
}
else
{
newFile.getParentFile().mkdirs();
if (newFile.createNewFile())
{
input = zipFile.getInputStream(entry);
output = new BufferedOutputStream(new FileOutputStream(newFile));
copyStreams(input, output);
}
}
}
catch (Throwable t)
{
unziped = false;
StudioLogger.error(FileUtil.class,
"Error extracting file: " + file.getAbsolutePath() + " to " //$NON-NLS-1$ //$NON-NLS-2$
+ extractDestination, t);
}
finally
{
try
{
if (input != null)
{
input.close();
}
if (output != null)
{
output.close();
}
}
catch (Throwable t)
{
//do nothing
}
subMonitor.worked(1);
}
}
}
return unziped;
}
public static boolean extractZipArchive(File file, File destination,
List<String> selectedEntries, IProgressMonitor monitor) throws IOException
{
SubMonitor subMonitor = SubMonitor.convert(monitor);
ZipFile zipFile = null;
CRC32 crc = new CRC32();
byte[] buf = new byte[BUFFER_SIZE];
File extractDestination = destination != null ? destination : file.getParentFile();
if (!extractDestination.exists())
{
extractDestination.mkdirs();
}
boolean unziped = true;
try
{
zipFile = new ZipFile(file);
}
catch (Throwable e)
{
unziped = false;
StudioLogger.error(FileUtil.class, "Error extracting file: " + file.getAbsolutePath() //$NON-NLS-1$
+ " to " + extractDestination, e); //$NON-NLS-1$
}
if (zipFile != null)
{
Enumeration<? extends ZipEntry> entries = zipFile.entries();
subMonitor.beginTask("Extracting files", Collections.list(entries).size()); //$NON-NLS-1$
entries = zipFile.entries();
InputStream input = null;
FileOutputStream output = null;
int diagReturn = IDialogConstants.YES_ID;
while (entries.hasMoreElements())
{
crc.reset();
try
{
ZipEntry entry = entries.nextElement();
if (selectedEntries.contains(entry.getName()))
{
File newFile = new File(extractDestination, entry.getName());
if ((diagReturn != IDialogConstants.YES_TO_ALL_ID) && newFile.exists())
{
diagReturn =
EclipseUtils.showQuestionYesAllCancelDialog(
UtilitiesNLS.FileUtil_File_Exists_Title, NLS.bind(
UtilitiesNLS.FileUtil_File_Exists_Message,
newFile.getAbsolutePath()));
}
if ((diagReturn == IDialogConstants.YES_ID)
|| (diagReturn == IDialogConstants.YES_TO_ALL_ID))
{
newFile.delete();
if (entry.isDirectory())
{
newFile.mkdirs();
}
else
{
newFile.getParentFile().mkdirs();
if (newFile.createNewFile())
{
input = zipFile.getInputStream(entry);
output = new FileOutputStream(newFile);
int length = 0;
while ((length = input.read(buf, 0, BUFFER_SIZE)) > 1)
{
output.write(buf, 0, length);
crc.update(buf, 0, length);
}
if (crc.getValue() != entry.getCrc())
{
throw new IOException();
}
}
}
}
else
{
diagReturn = IDialogConstants.YES_ID; //Attempt to extract next entry
}
}
}
catch (IOException e)
{
unziped = false;
StudioLogger.error(FileUtil.class,
"Error extracting file: " + file.getAbsolutePath() + " to " //$NON-NLS-1$ //$NON-NLS-2$
+ extractDestination, e);
throw e;
}
catch (Throwable t)
{
unziped = false;
StudioLogger.error(FileUtil.class,
"Error extracting file: " + file.getAbsolutePath() + " to " //$NON-NLS-1$ //$NON-NLS-2$
+ extractDestination, t);
}
finally
{
try
{
if (input != null)
{
input.close();
}
if (output != null)
{
output.close();
}
}
catch (Throwable t)
{
//do nothing
}
subMonitor.worked(1);
}
}
}
return unziped;
}
/**
* Unpack a tar file.
*
* @param file the file
* @param destination the destination path or null to unpack at the same directory of file
* @return true if unpacked, false otherwise
*/
public static boolean unpackTarFile(File artifactFile, String destination)
{
boolean unpacked = true;
String extractDestination = destination != null ? destination : artifactFile.getParent();
if (!extractDestination.endsWith(File.separator))
{
extractDestination += File.separator;
}
List<String> commandList = new LinkedList<String>();
commandList.add("tar"); //$NON-NLS-1$
String fileName = artifactFile.getName();
//tar.gz or tgz
if (fileName.endsWith("gz")) //$NON-NLS-1$
{
commandList.add("xzf"); //$NON-NLS-1$
}
//tar.bz2
else if (fileName.endsWith("bz2")) //$NON-NLS-1$
{
commandList.add("xjf"); //$NON-NLS-1$
}
//tar
else if (fileName.endsWith("tar")) //$NON-NLS-1$
{
commandList.add("xf"); //$NON-NLS-1$
}
else
{
unpacked = false;
}
if (unpacked)
{
commandList.add(artifactFile.getAbsolutePath());
File target = new File(extractDestination);
if (target.exists() && target.isDirectory() && target.canWrite())
{
try
{
Process p =
Runtime.getRuntime().exec(commandList.toArray(new String[0]), null,
target);
try
{
p.waitFor();
}
catch (InterruptedException e)
{
//do nothing
}
if (p.exitValue() != 0)
{
unpacked = false;
}
}
catch (IOException e)
{
unpacked = false;
}
}
}
return unpacked;
}
/**
* Copy the input stream to the output stream
* @param inputStream
* @param outputStream
* @throws IOException
*/
public static void copyStreams(InputStream inputStream, OutputStream outputStream)
throws IOException
{
byte[] buffer = new byte[1024];
int length;
while ((length = inputStream.read(buffer)) >= 0)
{
outputStream.write(buffer, 0, length);
}
}
/**
* Add a directory to a Project
* @param project
* @param parentFolder
* @param folderName
* @param monitor
* @throws CoreException
*/
public static void createProjectFolder(IProject project, String parentFolder,
String folderName, IProgressMonitor monitor) throws CoreException
{
monitor.beginTask(UtilitiesNLS.UI_Project_Creating_Folder_Task, 100);
try
{
monitor.setTaskName(UtilitiesNLS.UI_Project_Verifying_Folder_Task);
if (folderName.length() > 0)
{
monitor.worked(10);
IFolder folder = project.getFolder(parentFolder + folderName);
monitor.worked(10);
if (!folder.exists())
{
monitor.worked(10);
if (FileUtil.canWrite(folder.getLocation().toFile()))
{
monitor.worked(10);
monitor.setTaskName(UtilitiesNLS.UI_Project_Creating_Folder_Task);
folder.create(true, true, new SubProgressMonitor(monitor, 60));
}
else
{
String errMsg =
NLS.bind(
UtilitiesNLS.EXC_Project_CannotCreateFolderReadOnlyWorkspace,
folder.getLocation().toFile().toString());
IStatus status = new Status(IStatus.ERROR, CommonPlugin.PLUGIN_ID, errMsg);
throw new CoreException(status);
}
}
}
}
finally
{
monitor.done();
}
}
/**
* Given a directory descriptor represented by a {@link File}, creates it
* only if it does not exist. In case it does, try to create another
* one with its name plus "-1". If it does exists, try to create it with
* its name plus "+2", and so on...
* <br>
* Note that the directory is not fisically created. To do so, on must
* use the method {@link File#mkdir()}.
*
* @param directory Directory to be created.
*
* @return Returns the created directory as a {@link File}.
*/
public static File createUniqueDirectoryDescriptor(File directory)
{
if (directory.exists())
{
boolean exists = true;
int counter = 1;
String rootPath = directory.getAbsolutePath();
while (exists)
{
directory = new File(rootPath + "-" + counter); //$NON-NLS-1$
exists = directory.exists();
counter++;
}
}
return directory;
}
/**
* Return path with special characters escaped.
* Special characters are system dependent, there is a set for linux and another for mac.
* If {@code operationalSystem} is windows, the path is returned unchanged.
*
* @param path to be escaped.
* @param operatingSystem the target operation system that the path will be used.
* @return path with special characters escaped.
* */
public static String getEscapedPath(String path, String operatingSystem)
{
char[] specialCharSet = null;
if (operatingSystem.equals(Platform.OS_LINUX))
{
specialCharSet = LINUX_SPECIAL_CHAR;
}
else if (operatingSystem.equals(Platform.OS_MACOSX))
{
specialCharSet = MAC_SPECIAL_CHAR;
}
if ((path != null) && (specialCharSet != null))
{
for (char c : specialCharSet)
{
CharSequence target = String.valueOf(c);
CharSequence replacement = new String("\\" + String.valueOf(c)); //$NON-NLS-1$
path = path.replace(target, replacement);
}
}
return path;
}
/**
* Return path with special characters escaped.
* Special characters are system dependent, there is a set for linux and another for mac.
* If the system is windows, returns the path unchanged.
*
* @param path to be escaped
* @return path with special characters escaped.
* */
public static String getEscapedPath(String path)
{
return getEscapedPath(path, Platform.getOS());
}
/**
* Return path with special characters unescaped.
* Special characters are system dependent, there is a set for linux and another for mac.
* If the system is windows, returns the path unchanged.
*
* @param path to be unescaped
* @return path with special characters unescaped.
* */
public static String getUnescapedPath(String path)
{
char[] specialCharSet = null;
if (Platform.getOS().equals(Platform.OS_LINUX))
{
specialCharSet = LINUX_SPECIAL_CHAR;
}
else if (Platform.getOS().equals(Platform.OS_MACOSX))
{
specialCharSet = MAC_SPECIAL_CHAR;
}
if ((path != null) && (specialCharSet != null))
{
for (char c : specialCharSet)
{
CharSequence target = new String("\\") + String.valueOf(c); //$NON-NLS-1$
CharSequence replacement = String.valueOf(c);
path = path.replace(target, replacement);
}
}
return path;
}
public static String removeUnescapedQuotes(String path, String quoteReplacement)
{
//remove quotes and double quotes
char quotes[] =
{
'\'', '"'
};
boolean escaped = false;
for (int i = 0; i < path.length(); i++)
{
if (escaped == false)
{
if (path.charAt(i) == ESCAPE_CHAR)
{
escaped = true;
}
else
{
for (char quote : quotes)
{
if (path.charAt(i) == quote)
{
//split the string in two parts:
// - part1: before the quote
String part1 = path.substring(0, i);
// - part2: after the quote
String part2 = path.substring(i + 1, path.length());
//concatenate part1 and part2 with quoteReplacement in-between
//if quoteReplacement is the empty string (""), then part1 and part2 are juxtaposed
path = part1.concat(quoteReplacement).concat(part2);
}
}
}
}
else
{
//current character is escaped, next character can't be escaped
escaped = false;
}
}
return path;
}
/**
* Unescape characters and remove quotes and double quotes.
* Special characters are system dependent, there is a set for linux and another for mac.
* If the system is windows, returns the path unchanged.
*
* @param path to be cleaned.
* @param quoteReplacement string that will replace quotes and double quotes.
* @return path without quotes, double quotes and special characters unescaped.
* */
public static String getCleanPath(String path, String quoteReplacement)
{
path = removeUnescapedQuotes(path, quoteReplacement);
path = getUnescapedPath(path);
return path;
}
public static String calculateMd5Sum(File file) throws IOException
{
String md5Sum = null;
BigInteger hash = null;
FileInputStream fis;
fis = new FileInputStream(file);
byte[] buf = new byte[1500000];
try
{
MessageDigest digest = java.security.MessageDigest.getInstance("MD5"); //$NON-NLS-1$
int bytesRead = 0;
while ((bytesRead = fis.read(buf)) > 0)
{
digest.update(buf, 0, bytesRead);
}
hash = new BigInteger(1, digest.digest());
md5Sum = hash.toString(16);
}
catch (NoSuchAlgorithmException e)
{
// This exception should not happen, because we are using a valid
// hard
// coded value for the algorithm name. However, if it happens, log
// it.
warn("MOTODEV Studio could not find an instance of the MessageDigest for the MD5 algorithm"); //$NON-NLS-1$
throw new IOException(UtilitiesNLS.FileUtil_Get_MD5_Algorithm_Failed);
}
finally
{
if (fis != null)
{
fis.close();
}
}
if (md5Sum == null)
{
throw new IOException(NLS.bind(UtilitiesNLS.FileUtil_MD5_Calculation_Failed,
file.getAbsolutePath()));
}
return md5Sum;
}
/**
* This method is responsible to copy informed source file to informed
* target.
*
* @param sourceFile
* @param targetFile
* @throws IOException
*/
public static void copy(File sourceFile, File targetFile) throws IOException
{
OutputStream outputStream = new FileOutputStream(targetFile);
InputStream inputStream = new FileInputStream(sourceFile);
try
{
int length;
byte[] buffer = new byte[FileUtil.BUFFER_SIZE];
while ((length = inputStream.read(buffer)) >= 0)
{
outputStream.write(buffer, 0, length);
}
}
catch (IOException e)
{
throw new IOException("Error copying file:" + sourceFile.getAbsolutePath() + //$NON-NLS-1$
" to " + targetFile.getAbsolutePath()); //$NON-NLS-1$
}
finally
{
outputStream.close();
inputStream.close();
}
}
/**
* This method normalize a directory path.
*
* @param folder Full path to a directory
* @return The normalized path.
*/
public static String normalizePath(String folder)
{
return folder.endsWith(File.separator) ? folder : folder + File.separator;
}
/**
* Delete the specified file, recursively as necessary.
*
* @param file The file to delete
*/
public static void delete(File file)
{
if (file.exists())
{
if (file.isDirectory())
{
File[] files = file.listFiles();
for (int i = 0; i < files.length; i++)
{
delete(files[i]);
}
}
file.delete();
}
}
/**
* Delete the specified file, recursively as necessary.
*
* @param fileName The file to delete
*/
public static void delete(String fileName)
{
delete(new File(fileName));
}
/**
* This method creates the specified directory.
*
* @param directory The directory to create.
* @throws IOException
*/
public static void mkdir(String directory) throws IOException
{
File f = new File(directory);
if (f.exists())
{
if (f.isFile())
{
throw new IOException("Error creating directory:" + directory); //$NON-NLS-1$
}
}
else
{
if (!f.mkdirs())
{
throw new IOException("Error creating directory:" + directory); //$NON-NLS-1$
}
}
}
}