UnzipTask is an extension for AsyncTask which focus on Unzipping file and extract it to the one you've provided.

README.md

UnzipTask

UnzipTask is an extension for AsyncTask which focus on Unzipping file and extract it to the one you've provided.

Implementation

Using Builder

UnzipTask.Builder builder = new UnzipTask.Builder();
builder.setZipFile(zipFile);
builder.setDestination(outputFile);
builder.setListener(new UnzipTask.UnzipTaskCallback() {
    @Override
    public void onSuccess() {

    }

    @Override
    public void onFailed() {

    }
});
UnzipTask task = builder.build();
task.execute();

or

UnzipTask task = new UnzipTask.Builder()
        .setZipFile(zipFile)
        .setDestination(outputFile)
        .setListener(new UnzipTask.UnzipTaskCallback() {
            @Override
            public void onSuccess() {

            }

            @Override
            public void onFailed() {

            }
        })
        .build();
task.execute();

Without Builder

UnzipTask task = new UnzipTask(zipFile, outputFile, new UnzipTask.UnzipTaskCallback() {
    @Override
    public void onSuccess() {

    }

    @Override
    public void onFailed() {

    }
});
task.execute();

UnzipTask.java

public class UnzipTask extends AsyncTask<Void, Void, Boolean> {

    private static final String TAG = UnzipTask.class.getSimpleName();

    public void execute() {
        super.execute();
    }

    private File zipFile;
    private File destFile;

    private UnzipTaskCallback callback;

    public UnzipTask(File zipFile, File destFile) {
        this.zipFile = zipFile;
        this.destFile = destFile;
    }

    public UnzipTask(File zipFile, File destFile, UnzipTaskCallback callback) {
        this.zipFile = zipFile;
        this.destFile = destFile;
        this.callback = callback;
    }

    @Override
    protected Boolean doInBackground(Void... voids) {
        return unzip(zipFile, destFile);
    }

    @Override
    protected void onPostExecute(Boolean successful) {
        if (callback != null) {
            if (successful) {
                callback.onSuccess();
            } else {
                callback.onFailed();
            }
        }
    }

    /**
     * Size of the buffer to read/write data
     */
    private static final int BUFFER_SIZE = 4096;
  
    private boolean unzip(File zipFile, File destinationDir) {
        ZipFile zip = null;
        try {
            destinationDir.mkdirs();
            zip = new ZipFile(zipFile);
            Enumeration<? extends ZipEntry> zipFileEntries = zip.entries();
            while (zipFileEntries.hasMoreElements()) {
                ZipEntry entry = zipFileEntries.nextElement();
                String entryName = entry.getName();
                File destFile = new File(destinationDir, entryName);
                File destinationParent = destFile.getParentFile();
                if (destinationParent != null && !destinationParent.exists()) {
                    destinationParent.mkdirs();
                }
                if (!entry.isDirectory()) {
                    BufferedInputStream is = new BufferedInputStream(zip.getInputStream(entry));
                    int currentByte;
                    byte data[] = new byte[BUFFER_SIZE];
                    FileOutputStream fos = new FileOutputStream(destFile);
                    BufferedOutputStream dest = new BufferedOutputStream(fos, BUFFER_SIZE);
                    while ((currentByte = is.read(data, 0, BUFFER_SIZE)) != -1) {
                        dest.write(data, 0, currentByte);
                    }
                    dest.flush();
                    dest.close();
                    is.close();
                }
            }
        } catch (Exception e) {
            return false;
        } finally {
            if (zip != null) {
                try {
                    zip.close();
                } catch (IOException ignored) {

                }
            }
        }
        return true;
    }

    public interface UnzipTaskCallback {

        void onSuccess();

        void onFailed();

    }

    public static final class Builder {

        private File zipFile;
        private File destFile;

        private UnzipTaskCallback callback;

        public Builder() {
        }

        public Builder setZipFile(File zipFile) {
            this.zipFile = zipFile;
            return this;
        }

        public Builder setDestination(File destFile) {
            this.destFile = destFile;
            return this;
        }

        public Builder setListener(UnzipTaskCallback callback) {
            this.callback = callback;
            return this;
        }

        public UnzipTask build() {
            if (zipFile != null && destFile != null) {
                if (callback != null) {
                    return new UnzipTask(zipFile, destFile, callback);
                } else {
                    return new UnzipTask(zipFile, destFile);
                }
            } else {
                throw new UnsupportedOperationException("Zip File & Destination must not be empty!");
            }
        }

    }

}