Android Zip Unzip Directory unzipDirectory(File p2BeUnzippedDir, File pZipFile)

Description

unzip Directory

License

Apache License

Parameter

Parameter	Description
p2BeUnzippedDir	a parameter
pZipFile	a parameter

Return

the list of unzipped file names

Declaration

public static Vector<String> unzipDirectory(File p2BeUnzippedDir,
        File pZipFile)

Method Source Code

/**/*from w  w  w  .j av  a  2 s  .  co  m*/
 Copyright 2014 Jens Glufke

 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.
 * -----------------------------------------------------------------------<br>
 * 
 * class that can be used to operations on files like copy, deleteDir etc 
 */

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileFilter;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Arrays;
import java.util.Enumeration;
import java.util.Vector;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.zip.ZipEntry;
import java.util.zip.ZipException;
import java.util.zip.ZipFile;
import java.util.zip.ZipOutputStream;

public class Main{
    private static final String LOGTAG = FileUtil.class.getSimpleName();
    /**
     *
     *
     * @param p2BeUnzippedDir
     * @param pZipFile
     * @return the list of unzipped file names
     *
     */
    public static Vector<String> unzipDirectory(File p2BeUnzippedDir,
            File pZipFile) {
        if (p2BeUnzippedDir == null) {
            throw new IllegalArgumentException(
                    "parameter p2BeUnzippedDir must not be null");
        }
        if (!p2BeUnzippedDir.isDirectory()) {
            throw new IllegalArgumentException(
                    "parameter p2BeUnzippedDir has to be a directory");
        }
        if (pZipFile == null) {
            throw new IllegalArgumentException(
                    "parameter pZipFile must not be null");
        }
        if (pZipFile.isDirectory()) {
            throw new IllegalArgumentException(
                    "parameter pZipFile has to be a file and not a directory");
        }
        Vector<String> lFilenameList = new Vector<String>();
        try {
            ZipFile lZipFile = new ZipFile(pZipFile);
            Enumeration<? extends ZipEntry> lEntryEnum = lZipFile.entries();
            while (lEntryEnum.hasMoreElements()) {
                ZipEntry lEntry = lEntryEnum.nextElement();
                InputStream lIS = lZipFile.getInputStream(lEntry);
                BufferedInputStream lBIS = new BufferedInputStream(lIS);
                String lFilename = p2BeUnzippedDir.getAbsolutePath() + "/"
                        + lEntry.getName();
                new File(lFilename).getParentFile().mkdirs();
                FileOutputStream lFOS = new FileOutputStream(lFilename);
                BufferedOutputStream lBOS = new BufferedOutputStream(lFOS);
                FileUtil.copy(lBIS, lBOS);
                lBOS.close();
                lFilenameList.add(lFilename);
            }
            lZipFile.close();
        } catch (IOException lE) {
            LogWrapper.e(LOGTAG,
                    "can not unzip file:" + pZipFile.getAbsolutePath()
                            + " to:" + p2BeUnzippedDir);
        }
        return lFilenameList;
    }
    /**
     * 
     * @param pSourceFile
     * @param pTargetFile
     * @throws IOException
     */
    public static synchronized void copy(File pSourceFile, File pTargetFile)
            throws IOException {

        if (!pSourceFile.getCanonicalPath().equals(
                pTargetFile.getCanonicalPath())) {

            pTargetFile.getParentFile().mkdirs();

            FileInputStream lFIS = new FileInputStream(pSourceFile);
            FileOutputStream lFOS = new FileOutputStream(
                    pTargetFile.getCanonicalPath());
            copy(lFIS, lFOS);
            lFOS.close();
        }
    }
    /**
     * destination is not closed on exit of method !
     * @param pSourceStream
     * @param pTargetStream
     * @throws IOException
     */
    public static synchronized void copy(InputStream pSourceStream,
            OutputStream pTargetStream) throws IOException {
        copy(pSourceStream, pTargetStream, true);
    }
    /**
     * destination is not closed on exit of method !
     * @param pSourceStream
     * @param pTargetStream
     * @param closeSource define if the source id closed after copying
     * @throws IOException
     */
    public static synchronized void copy(InputStream pSourceStream,
            OutputStream pTargetStream, boolean closeSource)
            throws IOException {

        final int buffSize = 1024;
        final byte[] lBuf = new byte[buffSize];

        int lBytesRead = 0;
        while ((lBytesRead = pSourceStream.read(lBuf, 0, buffSize)) != -1) {
            pTargetStream.write(lBuf, 0, lBytesRead);
        }
        if (closeSource) {
            pSourceStream.close();
        }
    }
    /**
     * 
     * @param pSourceFile
     * @param pTargetFile
     * @throws IOException
     */
    public static synchronized void copy(String pSourceFile,
            String pTargetFile) throws IOException {

        copy(new File(pSourceFile), new File(pTargetFile));
    }
    /**
     * 
     * @param pFile
     * @return
     */
    public static String getCanonicalPath(File pFile) {

        String lReturnPath = pFile.getAbsolutePath();
        lReturnPath = lReturnPath.replaceAll("\\\\", "/");

        final String regExp1 = "()[^/]+/(\\.\\.)";
        final Pattern pattern1 = Pattern.compile(regExp1);
        final String regExp2 = "([^/]+/)(\\.)";
        final Pattern pattern2 = Pattern.compile(regExp2);
        final String regExp3 = "(/)(/)";
        final Pattern pattern3 = Pattern.compile(regExp3);

        for (Pattern lPattern : new Pattern[] { pattern1, pattern2,
                pattern3 }) {
            Matcher lMatcher = lPattern.matcher(lReturnPath);
            while (lMatcher.find()) {
                lReturnPath = lMatcher.replaceFirst(lMatcher.group(1));
                lMatcher = lPattern.matcher(lReturnPath);
            }
        }
        if (lReturnPath.endsWith("/")) {
            lReturnPath = lReturnPath
                    .substring(0, lReturnPath.length() - 1);
        }
        return lReturnPath;
    }
    /**
     * 
     * find a file in pDir and its sub directories that matches pFilter
     * @param pFoundFiles
     * @param pDir
     * @param pFilter
     * @return
     *
     */
    public static Vector<File> find(Vector<File> pFoundFiles, File pDir,
            FileFilter pFilter) {
        if (pDir.isDirectory()) {
            File[] lFoundFiles = pDir.listFiles(pFilter);
            if (lFoundFiles != null && lFoundFiles.length > 0) {
                pFoundFiles.addAll(Arrays.asList(lFoundFiles));
            }
            for (File lFile : pDir.listFiles()) {
                find(pFoundFiles, lFile, pFilter);
            }
        }
        return pFoundFiles;
    }
    /**
     * find all files in pDirectory and its sub directories whose absolute path
     * matches pRegex
     * @param pDirectory
     * @param pRegex
     * @return
     */
    public static synchronized Vector<File> find(File pDirectory,
            String pRegex) {
        Vector<File> lReturn = new Vector<File>();
        lReturn = find(lReturn, pDirectory, new RegExpFileFilter(pRegex));
        return lReturn;
    }
}

Android Zip Unzip Directory unzipDirectory(File p2BeUnzippedDir, File pZipFile)

Description

License

Parameter

Return

Declaration

Method Source Code

Related