path: root/src/plugins/common/src/com/motorola/studio/android/common/utilities/FileUtil.java

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

}