Java tutorial
/* * 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$ } } } }