/src/com/android/sdklib/internal/repository/Archive.java

/*

 * Copyright (C) 2009 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.android.sdklib.internal.repository;



import com.android.sdklib.SdkConstants;

import com.android.sdklib.SdkManager;



import org.apache.commons.compress.archivers.zip.ZipArchiveEntry;

import org.apache.commons.compress.archivers.zip.ZipFile;



import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.net.URL;

import java.security.MessageDigest;

import java.security.NoSuchAlgorithmException;

import java.util.Enumeration;

import java.util.Properties;





/**

 * A {@link Archive} is the base class for "something" that can be downloaded from

 * the SDK repository.

 * <p/>

 * A package has some attributes (revision, description) and a list of archives

 * which represent the downloadable bits.

 * <p/>

 * Packages are offered by a {@link RepoSource} (a download site).

 */

public class Archive implements IDescription {



    public static final int NUM_MONITOR_INC = 100;

    private static final String PROP_OS   = "Archive.Os";       //$NON-NLS-1$

    private static final String PROP_ARCH = "Archive.Arch";     //$NON-NLS-1$



    /** The checksum type. */

    public enum ChecksumType {

        /** A SHA1 checksum, represented as a 40-hex string. */

        SHA1("SHA-1");  //$NON-NLS-1$



        private final String mAlgorithmName;



        /**

         * Constructs a {@link ChecksumType} with the algorigth name

         * suitable for {@link MessageDigest#getInstance(String)}.

         * <p/>

         * These names are officially documented at

         * http://java.sun.com/javase/6/docs/technotes/guides/security/StandardNames.html#MessageDigest

         */

        private ChecksumType(String algorithmName) {

            mAlgorithmName = algorithmName;

        }



        /**

         * Returns a new {@link MessageDigest} instance for this checksum type.

         * @throws NoSuchAlgorithmException if this algorithm is not available.

         */

        public MessageDigest getMessageDigest() throws NoSuchAlgorithmException {

            return MessageDigest.getInstance(mAlgorithmName);

        }

    }



    /** The OS that this archive can be downloaded on. */

    public enum Os {

        ANY("Any"),

        LINUX("Linux"),

        MACOSX("MacOS X"),

        WINDOWS("Windows");



        private final String mUiName;



        private Os(String uiName) {

            mUiName = uiName;

        }



        /** Returns the UI name of the OS. */

        public String getUiName() {

            return mUiName;

        }



        /** Returns the XML name of the OS. */

        public String getXmlName() {

            return toString().toLowerCase();

        }



        /**

         * Returns the current OS as one of the {@link Os} enum values or null.

         */

        public static Os getCurrentOs() {

            String os = System.getProperty("os.name");          //$NON-NLS-1$

            if (os.startsWith("Mac")) {                         //$NON-NLS-1$

                return Os.MACOSX;



            } else if (os.startsWith("Windows")) {              //$NON-NLS-1$

                return Os.WINDOWS;



            } else if (os.startsWith("Linux")) {                //$NON-NLS-1$

                return Os.LINUX;

            }



            return null;

        }



        /** Returns true if this OS is compatible with the current one. */

        public boolean isCompatible() {

            if (this == ANY) {

                return true;

            }



            Os os = getCurrentOs();

            return this == os;

        }

    }



    /** The Architecture that this archive can be downloaded on. */

    public enum Arch {

        ANY("Any"),

        PPC("PowerPC"),

        X86("x86"),

        X86_64("x86_64");



        private final String mUiName;



        private Arch(String uiName) {

            mUiName = uiName;

        }



        /** Returns the UI name of the architecture. */

        public String getUiName() {

            return mUiName;

        }



        /** Returns the XML name of the architecture. */

        public String getXmlName() {

            return toString().toLowerCase();

        }



        /**

         * Returns the current architecture as one of the {@link Arch} enum values or null.

         */

        public static Arch getCurrentArch() {

            // Values listed from http://lopica.sourceforge.net/os.html

            String arch = System.getProperty("os.arch");



            if (arch.equalsIgnoreCase("x86_64") || arch.equalsIgnoreCase("amd64")) {

                return Arch.X86_64;



            } else if (arch.equalsIgnoreCase("x86")

                    || arch.equalsIgnoreCase("i386")

                    || arch.equalsIgnoreCase("i686")) {

                return Arch.X86;



            } else if (arch.equalsIgnoreCase("ppc") || arch.equalsIgnoreCase("PowerPC")) {

                return Arch.PPC;

            }



            return null;

        }



        /** Returns true if this architecture is compatible with the current one. */

        public boolean isCompatible() {

            if (this == ANY) {

                return true;

            }



            Arch arch = getCurrentArch();

            return this == arch;

        }

    }



    private final Os     mOs;

    private final Arch   mArch;

    private final String mUrl;

    private final long   mSize;

    private final String mChecksum;

    private final ChecksumType mChecksumType = ChecksumType.SHA1;

    private final Package mPackage;

    private final String mLocalOsPath;

    private final boolean mIsLocal;



    /**

     * Creates a new remote archive.

     */

    Archive(Package pkg, Os os, Arch arch, String url, long size, String checksum) {

        mPackage = pkg;

        mOs = os;

        mArch = arch;

        mUrl = url;

        mLocalOsPath = null;

        mSize = size;

        mChecksum = checksum;

        mIsLocal = false;

    }



    /**

     * Creates a new local archive.

     * Uses the properties from props first, if possible. Props can be null.

     */

    Archive(Package pkg, Properties props, Os os, Arch arch, String localOsPath) {

        mPackage = pkg;



        mOs   = props == null ? os   : Os.valueOf(  props.getProperty(PROP_OS,   os.toString()));

        mArch = props == null ? arch : Arch.valueOf(props.getProperty(PROP_ARCH, arch.toString()));



        mUrl = null;

        mLocalOsPath = localOsPath;

        mSize = 0;

        mChecksum = "";

        mIsLocal = true;

    }



    /**

     * Save the properties of the current archive in the give {@link Properties} object.

     * These properties will later be give the constructor that takes a {@link Properties} object.

     */

    void saveProperties(Properties props) {

        props.setProperty(PROP_OS,   mOs.toString());

        props.setProperty(PROP_ARCH, mArch.toString());

    }



    /**

     * Returns true if this is a locally installed archive.

     * Returns false if this is a remote archive that needs to be downloaded.

     */

    public boolean isLocal() {

        return mIsLocal;

    }



    /**

     * Returns the package that created and owns this archive.

     * It should generally not be null.

     */

    public Package getParentPackage() {

        return mPackage;

    }



    /**

     * Returns the archive size, an int > 0.

     * Size will be 0 if this a local installed folder of unknown size.

     */

    public long getSize() {

        return mSize;

    }



    /**

     * Returns the SHA1 archive checksum, as a 40-char hex.

     * Can be empty but not null for local installed folders.

     */

    public String getChecksum() {

        return mChecksum;

    }



    /**

     * Returns the checksum type, always {@link ChecksumType#SHA1} right now.

     */

    public ChecksumType getChecksumType() {

        return mChecksumType;

    }



    /**

     * Returns the download archive URL, either absolute or relative to the repository xml.

     * Always return null for a local installed folder.

     * @see #getLocalOsPath()

     */

    public String getUrl() {

        return mUrl;

    }



    /**

     * Returns the local OS folder where a local archive is installed.

     * Always return null for remote archives.

     * @see #getUrl()

     */

    public String getLocalOsPath() {

        return mLocalOsPath;

    }



    /**

     * Returns the archive {@link Os} enum.

     * Can be null for a local installed folder on an unknown OS.

     */

    public Os getOs() {

        return mOs;

    }



    /**

     * Returns the archive {@link Arch} enum.

     * Can be null for a local installed folder on an unknown architecture.

     */

    public Arch getArch() {

        return mArch;

    }



    /**

     * Generates a description for this archive of the OS/Arch supported by this archive.

     */

    public String getOsDescription() {

        String os;

        if (mOs == null) {

            os = "unknown OS";

        } else if (mOs == Os.ANY) {

            os = "any OS";

        } else {

            os = mOs.getUiName();

        }



        String arch = "";                               //$NON-NLS-1$

        if (mArch != null && mArch != Arch.ANY) {

            arch = mArch.getUiName();

        }



        return String.format("%1$s%2$s%3$s",

                os,

                arch.length() > 0 ? " " : "",           //$NON-NLS-2$

                arch);

    }



    /**

     * Generates a short description for this archive.

     */

    public String getShortDescription() {

        return String.format("Archive for %1$s", getOsDescription());

    }



    /**

     * Generates a longer description for this archive.

     */

    public String getLongDescription() {

        return String.format("%1$s\nSize: %2$d MiB\nSHA1: %3$s",

                getShortDescription(),

                Math.round(getSize() / (1024*1024)),

                getChecksum());

    }



    /**

     * Returns true if this archive can be installed on the current platform.

     */

    public boolean isCompatible() {

        return getOs().isCompatible() && getArch().isCompatible();

    }



    /**

     * Delete the archive folder if this is a local archive.

     */

    public void deleteLocal() {

        if (isLocal()) {

            deleteFileOrFolder(new File(getLocalOsPath()));

        }

    }



    /**

     * Install this {@link Archive}s.

     * The archive will be skipped if it is incompatible.

     *

     * @return True if the archive was installed, false otherwise.

     */

    public boolean install(String osSdkRoot,

            boolean forceHttp,

            SdkManager sdkManager,

            ITaskMonitor monitor) {



        Package pkg = getParentPackage();



        File archiveFile = null;

        String name = pkg.getShortDescription();



        if (pkg instanceof ExtraPackage && !((ExtraPackage) pkg).isPathValid()) {

            monitor.setResult("Skipping %1$s: %2$s is not a valid install path.",

                    name,

                    ((ExtraPackage) pkg).getPath());

            return false;

        }



        if (isLocal()) {

            // This should never happen.

            monitor.setResult("Skipping already installed archive: %1$s for %2$s",

                    name,

                    getOsDescription());

            return false;

        }



        if (!isCompatible()) {

            monitor.setResult("Skipping incompatible archive: %1$s for %2$s",

                    name,

                    getOsDescription());

            return false;

        }



        archiveFile = downloadFile(osSdkRoot, monitor, forceHttp);

        if (archiveFile != null) {

            // Unarchive calls the pre/postInstallHook methods.

            if (unarchive(osSdkRoot, archiveFile, sdkManager, monitor)) {

                monitor.setResult("Installed %1$s", name);

                // Delete the temp archive if it exists, only on success

                deleteFileOrFolder(archiveFile);

                return true;

            }

        }



        return false;

    }



    /**

     * Downloads an archive and returns the temp file with it.

     * Caller is responsible with deleting the temp file when done.

     */

    private File downloadFile(String osSdkRoot, ITaskMonitor monitor, boolean forceHttp) {



        String name = getParentPackage().getShortDescription();

        String desc = String.format("Downloading %1$s", name);

        monitor.setDescription(desc);

        monitor.setResult(desc);



        String link = getUrl();

        if (!link.startsWith("http://")                          //$NON-NLS-1$

                && !link.startsWith("https://")                  //$NON-NLS-1$

                && !link.startsWith("ftp://")) {                 //$NON-NLS-1$

            // Make the URL absolute by prepending the source

            Package pkg = getParentPackage();

            RepoSource src = pkg.getParentSource();

            if (src == null) {

                monitor.setResult("Internal error: no source for archive %1$s", name);

                return null;

            }



            // take the URL to the repository.xml and remove the last component

            // to get the base

            String repoXml = src.getUrl();

            int pos = repoXml.lastIndexOf('/');

            String base = repoXml.substring(0, pos + 1);



            link = base + link;

        }



        if (forceHttp) {

            link = link.replaceAll("https://", "http://");  //$NON-NLS-1$ //$NON-NLS-2$

        }



        // Get the basename of the file we're downloading, i.e. the last component

        // of the URL

        int pos = link.lastIndexOf('/');

        String base = link.substring(pos + 1);



        // Rather than create a real temp file in the system, we simply use our

        // temp folder (in the SDK base folder) and use the archive name for the

        // download. This allows us to reuse or continue downloads.



        File tmpFolder = getTempFolder(osSdkRoot);

        if (!tmpFolder.isDirectory()) {

            if (tmpFolder.isFile()) {

                deleteFileOrFolder(tmpFolder);

            }

            if (!tmpFolder.mkdirs()) {

                monitor.setResult("Failed to create directory %1$s", tmpFolder.getPath());

                return null;

            }

        }

        File tmpFile = new File(tmpFolder, base);



        // if the file exists, check if its checksum & size. Use it if complete

        if (tmpFile.exists()) {

            if (tmpFile.length() == getSize() &&

                    fileChecksum(tmpFile, monitor).equalsIgnoreCase(getChecksum())) {

                // File is good, let's use it.

                return tmpFile;

            }



            // Existing file is either of different size or content.

            // TODO: continue download when we support continue mode.

            // Right now, let's simply remove the file and start over.

            deleteFileOrFolder(tmpFile);

        }



        if (fetchUrl(tmpFile, link, desc, monitor)) {

            // Fetching was successful, let's use this file.

            return tmpFile;

        } else {

            // Delete the temp file if we aborted the download

            // TODO: disable this when we want to support partial downloads!

            deleteFileOrFolder(tmpFile);

            return null;

        }

    }



    /**

     * Computes the SHA-1 checksum of the content of the given file.

     * Returns an empty string on error (rather than null).

     */

    private String fileChecksum(File tmpFile, ITaskMonitor monitor) {

        InputStream is = null;

        try {

            is = new FileInputStream(tmpFile);



            MessageDigest digester = getChecksumType().getMessageDigest();



            byte[] buf = new byte[65536];

            int n;



            while ((n = is.read(buf)) >= 0) {

                if (n > 0) {

                    digester.update(buf, 0, n);

                }

            }



            return getDigestChecksum(digester);



        } catch (FileNotFoundException e) {

            // The FNF message is just the URL. Make it a bit more useful.

            monitor.setResult("File not found: %1$s", e.getMessage());



        } catch (Exception e) {

            monitor.setResult(e.getMessage());



        } finally {

            if (is != null) {

                try {

                    is.close();

                } catch (IOException e) {

                    // pass

                }

            }

        }



        return "";  //$NON-NLS-1$

    }



    /**

     * Returns the SHA-1 from a {@link MessageDigest} as an hex string

     * that can be compared with {@link #getChecksum()}.

     */

    private String getDigestChecksum(MessageDigest digester) {

        int n;

        // Create an hex string from the digest

        byte[] digest = digester.digest();

        n = digest.length;

        String hex = "0123456789abcdef";                     //$NON-NLS-1$

        char[] hexDigest = new char[n * 2];

        for (int i = 0; i < n; i++) {

            int b = digest[i] & 0x0FF;

            hexDigest[i*2 + 0] = hex.charAt(b >>> 4);

            hexDigest[i*2 + 1] = hex.charAt(b & 0x0f);

        }



        return new String(hexDigest);

    }



    /**

     * Actually performs the download.

     * Also computes the SHA1 of the file on the fly.

     * <p/>

     * Success is defined as downloading as many bytes as was expected and having the same

     * SHA1 as expected. Returns true on success or false if any of those checks fail.

     * <p/>

     * Increments the monitor by {@link #NUM_MONITOR_INC}.

     */

    private boolean fetchUrl(File tmpFile,

            String urlString,

            String description,

            ITaskMonitor monitor) {

        URL url;



        description += " (%1$d%%, %2$.0f KiB/s, %3$d %4$s left)";



        FileOutputStream os = null;

        InputStream is = null;

        try {

            url = new URL(urlString);

            is = url.openStream();

            os = new FileOutputStream(tmpFile);



            MessageDigest digester = getChecksumType().getMessageDigest();



            byte[] buf = new byte[65536];

            int n;



            long total = 0;

            long size = getSize();

            long inc = size / NUM_MONITOR_INC;

            long next_inc = inc;



            long startMs = System.currentTimeMillis();

            long nextMs = startMs + 2000;  // start update after 2 seconds



            while ((n = is.read(buf)) >= 0) {

                if (n > 0) {

                    os.write(buf, 0, n);

                    digester.update(buf, 0, n);

                }



                long timeMs = System.currentTimeMillis();



                total += n;

                if (total >= next_inc) {

                    monitor.incProgress(1);

                    next_inc += inc;

                }



                if (timeMs > nextMs) {

                    long delta = timeMs - startMs;

                    if (total > 0 && delta > 0) {

                        // percent left to download

                        int percent = (int) (100 * total / size);

                        // speed in KiB/s

                        float speed = (float)total / (float)delta * (1000.f / 1024.f);

                        // time left to download the rest at the current KiB/s rate

                        int timeLeft = (speed > 1e-3) ?

                                               (int)(((size - total) / 1024.0f) / speed) :

                                               0;

                        String timeUnit = "seconds";

                        if (timeLeft > 120) {

                            timeUnit = "minutes";

                            timeLeft /= 60;

                        }



                        monitor.setDescription(description, percent, speed, timeLeft, timeUnit);

                    }

                    nextMs = timeMs + 1000;  // update every second

                }



                if (monitor.isCancelRequested()) {

                    monitor.setResult("Download aborted by user at %1$d bytes.", total);

                    return false;

                }



            }



            if (total != size) {

                monitor.setResult("Download finished with wrong size. Expected %1$d bytes, got %2$d bytes.",

                        size, total);

                return false;

            }



            // Create an hex string from the digest

            String actual   = getDigestChecksum(digester);

            String expected = getChecksum();

            if (!actual.equalsIgnoreCase(expected)) {

                monitor.setResult("Download finished with wrong checksum. Expected %1$s, got %2$s.",

                        expected, actual);

                return false;

            }



            return true;



        } catch (FileNotFoundException e) {

            // The FNF message is just the URL. Make it a bit more useful.

            monitor.setResult("File not found: %1$s", e.getMessage());



        } catch (Exception e) {

            monitor.setResult(e.getMessage());



        } finally {

            if (os != null) {

                try {

                    os.close();

                } catch (IOException e) {

                    // pass

                }

            }



            if (is != null) {

                try {

                    is.close();

                } catch (IOException e) {

                    // pass

                }

            }

        }



        return false;

    }



    /**

     * Install the given archive in the given folder.

     */

    private boolean unarchive(String osSdkRoot,

            File archiveFile,

            SdkManager sdkManager,

            ITaskMonitor monitor) {

        boolean success = false;

        Package pkg = getParentPackage();

        String pkgName = pkg.getShortDescription();

        String pkgDesc = String.format("Installing %1$s", pkgName);

        monitor.setDescription(pkgDesc);

        monitor.setResult(pkgDesc);



        // We always unzip in a temp folder which name depends on the package type

        // (e.g. addon, tools, etc.) and then move the folder to the destination folder.

        // If the destination folder exists, it will be renamed and deleted at the very

        // end if everything succeeded.



        String pkgKind = pkg.getClass().getSimpleName();



        File destFolder = null;

        File unzipDestFolder = null;

        File oldDestFolder = null;



        try {

            // Find a new temp folder that doesn't exist yet

            unzipDestFolder = createTempFolder(osSdkRoot, pkgKind, "new");  //$NON-NLS-1$



            if (unzipDestFolder == null) {

                // this should not seriously happen.

                monitor.setResult("Failed to find a temp directory in %1$s.", osSdkRoot);

                return false;

            }



            if (!unzipDestFolder.mkdirs()) {

                monitor.setResult("Failed to create directory %1$s", unzipDestFolder.getPath());

                return false;

            }



            String[] zipRootFolder = new String[] { null };

            if (!unzipFolder(archiveFile, getSize(),

                    unzipDestFolder, pkgDesc,

                    zipRootFolder, monitor)) {

                return false;

            }



            if (!generateSourceProperties(unzipDestFolder)) {

                return false;

            }



            // Compute destination directory

            destFolder = pkg.getInstallFolder(osSdkRoot, zipRootFolder[0], sdkManager);



            if (destFolder == null) {

                // this should not seriously happen.

                monitor.setResult("Failed to compute installation directory for %1$s.", pkgName);

                return false;

            }



            if (!pkg.preInstallHook(this, monitor, osSdkRoot, destFolder)) {

                monitor.setResult("Skipping archive: %1$s", pkgName);

                return false;

            }



            // Swap the old folder by the new one.

            // We have 2 "folder rename" (aka moves) to do.

            // They must both succeed in the right order.

            boolean move1done = false;

            boolean move2done = false;

            while (!move1done || !move2done) {

                File renameFailedForDir = null;



                // Case where the dest dir already exists

                if (!move1done) {

                    if (destFolder.isDirectory()) {

                        // Create a new temp/old dir

                        if (oldDestFolder == null) {

                            oldDestFolder = createTempFolder(osSdkRoot, pkgKind, "old");  //$NON-NLS-1$

                        }

                        if (oldDestFolder == null) {

                            // this should not seriously happen.

                            monitor.setResult("Failed to find a temp directory in %1$s.", osSdkRoot);

                            return false;

                        }



                        // try to move the current dest dir to the temp/old one

                        if (!destFolder.renameTo(oldDestFolder)) {

                            monitor.setResult("Failed to rename directory %1$s to %2$s.",

                                    destFolder.getPath(), oldDestFolder.getPath());

                            renameFailedForDir = destFolder;

                        }

                    }



                    move1done = (renameFailedForDir == null);

                }



                // Case where there's no dest dir or we successfully moved it to temp/old

                // We now try to move the temp/unzip to the dest dir

                if (move1done && !move2done) {

                    if (renameFailedForDir == null && !unzipDestFolder.renameTo(destFolder)) {

                        monitor.setResult("Failed to rename directory %1$s to %2$s",

                                unzipDestFolder.getPath(), destFolder.getPath());

                        renameFailedForDir = unzipDestFolder;

                    }



                    move2done = (renameFailedForDir == null);

                }



                if (renameFailedForDir != null) {

                    if (SdkConstants.CURRENT_PLATFORM == SdkConstants.PLATFORM_WINDOWS) {



                        String msg = String.format(

                                "-= Warning ! =-\n" +

                                "A folder failed to be renamed or moved. On Windows this " +

                                "typically means that a program is using that folder (for example " +

                                "Windows Explorer or your anti-virus software.)\n" +

                                "Please momentarily deactivate your anti-virus software.\n" +

                                "Please also close any running programs that may be accessing " +

                                "the directory '%1$s'.\n" +

                                "When ready, press YES to try again.",

                                renameFailedForDir.getPath());



                        if (monitor.displayPrompt("SDK Manager: failed to install", msg)) {

                            // loop, trying to rename the temp dir into the destination

                            continue;

                        }



                    }

                    return false;

                }

                break;

            }



            unzipDestFolder = null;

            success = true;

            pkg.postInstallHook(this, monitor, destFolder);

            return true;



        } finally {

            // Cleanup if the unzip folder is still set.

            deleteFileOrFolder(oldDestFolder);

            deleteFileOrFolder(unzipDestFolder);



            // In case of failure, we call the postInstallHool with a null directory

            if (!success) {

                pkg.postInstallHook(this, monitor, null /*installDir*/);

            }

        }

    }



    /**

     * Unzips a zip file into the given destination directory.

     *

     * The archive file MUST have a unique "root" folder. This root folder is skipped when

     * unarchiving. However we return that root folder name to the caller, as it can be used

     * as a template to know what destination directory to use in the Add-on case.

     */

    @SuppressWarnings("unchecked")

    private boolean unzipFolder(File archiveFile,

            long compressedSize,

            File unzipDestFolder,

            String description,

            String[] outZipRootFolder,

            ITaskMonitor monitor) {



        description += " (%1$d%%)";



        ZipFile zipFile = null;

        try {

            zipFile = new ZipFile(archiveFile);



            // figure if we'll need to set the unix permission

            boolean usingUnixPerm = SdkConstants.CURRENT_PLATFORM == SdkConstants.PLATFORM_DARWIN ||

                    SdkConstants.CURRENT_PLATFORM == SdkConstants.PLATFORM_LINUX;



            // To advance the percent and the progress bar, we don't know the number of

            // items left to unzip. However we know the size of the archive and the size of

            // each uncompressed item. The zip file format overhead is negligible so that's

            // a good approximation.

            long incStep = compressedSize / NUM_MONITOR_INC;

            long incTotal = 0;

            long incCurr = 0;

            int lastPercent = 0;



            byte[] buf = new byte[65536];



            Enumeration<ZipArchiveEntry> entries = zipFile.getEntries();

            while (entries.hasMoreElements()) {

                ZipArchiveEntry entry = entries.nextElement();



                String name = entry.getName();



                // ZipFile entries should have forward slashes, but not all Zip

                // implementations can be expected to do that.

                name = name.replace('\\', '/');



                // Zip entries are always packages in a top-level directory

                // (e.g. docs/index.html). However we want to use our top-level

                // directory so we drop the first segment of the path name.

                int pos = name.indexOf('/');

                if (pos < 0 || pos == name.length() - 1) {

                    continue;

                } else {

                    if (outZipRootFolder[0] == null && pos > 0) {

                        outZipRootFolder[0] = name.substring(0, pos);

                    }

                    name = name.substring(pos + 1);

                }



                File destFile = new File(unzipDestFolder, name);



                if (name.endsWith("/")) {  //$NON-NLS-1$

                    // Create directory if it doesn't exist yet. This allows us to create

                    // empty directories.

                    if (!destFile.isDirectory() && !destFile.mkdirs()) {

                        monitor.setResult("Failed to create temp directory %1$s",

                                destFile.getPath());

                        return false;

                    }

                    continue;

                } else if (name.indexOf('/') != -1) {

                    // Otherwise it's a file in a sub-directory.

                    // Make sure the parent directory has been created.

                    File parentDir = destFile.getParentFile();

                    if (!parentDir.isDirectory()) {

                        if (!parentDir.mkdirs()) {

                            monitor.setResult("Failed to create temp directory %1$s",

                                    parentDir.getPath());

                            return false;

                        }

                    }

                }



                FileOutputStream fos = null;

                try {

                    fos = new FileOutputStream(destFile);

                    int n;

                    InputStream entryContent = zipFile.getInputStream(entry);

                    while ((n = entryContent.read(buf)) != -1) {

                        if (n > 0) {

                            fos.write(buf, 0, n);

                        }

                    }

                } finally {

                    if (fos != null) {

                        fos.close();

                    }

                }



                // if needed set the permissions.

                if (usingUnixPerm && destFile.isFile()) {

                    // get the mode and test if it contains the executable bit

                    int mode = entry.getUnixMode();

                    if ((mode & 0111) != 0) {

                        setExecutablePermission(destFile);

                    }

                }



                // Increment progress bar to match. We update only between files.

                for(incTotal += entry.getCompressedSize(); incCurr < incTotal; incCurr += incStep) {

                    monitor.incProgress(1);

                }



                int percent = (int) (100 * incTotal / compressedSize);

                if (percent != lastPercent) {

                    monitor.setDescription(description, percent);

                    lastPercent = percent;

                }



                if (monitor.isCancelRequested()) {

                    return false;

                }

            }



            return true;



        } catch (IOException e) {

            monitor.setResult("Unzip failed: %1$s", e.getMessage());



        } finally {

            if (zipFile != null) {

                try {

                    zipFile.close();

                } catch (IOException e) {

                    // pass

                }

            }

        }



        return false;

    }



    /**

     * Creates a temp folder in the form of osBasePath/temp/prefix.suffixNNN.

     * <p/>

     * This operation is not atomic so there's no guarantee the folder can't get

     * created in between. This is however unlikely and the caller can assume the

     * returned folder does not exist yet.

     * <p/>

     * Returns null if no such folder can be found (e.g. if all candidates exist,

     * which is rather unlikely) or if the base temp folder cannot be created.

     */

    private File createTempFolder(String osBasePath, String prefix, String suffix) {

        File baseTempFolder = getTempFolder(osBasePath);



        if (!baseTempFolder.isDirectory()) {

            if (baseTempFolder.isFile()) {

                deleteFileOrFolder(baseTempFolder);

            }

            if (!baseTempFolder.mkdirs()) {

                return null;

            }

        }



        for (int i = 1; i < 100; i++) {

            File folder = new File(baseTempFolder,

                    String.format("%1$s.%2$s%3$02d", prefix, suffix, i));  //$NON-NLS-1$

            if (!folder.exists()) {

                return folder;

            }

        }

        return null;

    }



    /**

     * Returns the temp folder used by the SDK Manager.

     * This folder is always at osBasePath/temp.

     */

    private File getTempFolder(String osBasePath) {

        File baseTempFolder = new File(osBasePath, "temp");     //$NON-NLS-1$

        return baseTempFolder;

    }



    /**

     * Deletes a file or a directory.

     * Directories are deleted recursively.

     * The argument can be null.

     */

    private void deleteFileOrFolder(File fileOrFolder) {

        if (fileOrFolder != null) {

            if (fileOrFolder.isDirectory()) {

                // Must delete content recursively first

                for (File item : fileOrFolder.listFiles()) {

                    deleteFileOrFolder(item);

                }

            }

            if (!fileOrFolder.delete()) {

                fileOrFolder.deleteOnExit();

            }

        }

    }



    /**

     * Generates a source.properties in the destination folder that contains all the infos

     * relevant to this archive, this package and the source so that we can reload them

     * locally later.

     */

    private boolean generateSourceProperties(File unzipDestFolder) {

        Properties props = new Properties();



        saveProperties(props);

        mPackage.saveProperties(props);



        FileOutputStream fos = null;

        try {

            File f = new File(unzipDestFolder, SdkConstants.FN_SOURCE_PROP);



            fos = new FileOutputStream(f);



            props.store( fos, "## Android Tool: Source of this archive.");  //$NON-NLS-1$



            return true;

        } catch (IOException e) {

            e.printStackTrace();

        } finally {

            if (fos != null) {

                try {

                    fos.close();

                } catch (IOException e) {

                }

            }

        }



        return false;

    }



    /**

     * Sets the executable Unix permission (0777) on a file or folder.

     * @param file The file to set permissions on.

     * @throws IOException If an I/O error occurs

     */

    private void setExecutablePermission(File file) throws IOException {

        Runtime.getRuntime().exec(new String[] {

           "chmod", "777", file.getAbsolutePath()

        });

    }

}