src/com/android/documentsui/archives/ArchiveHandle.java - LeafOS-Project/android_packages_apps_DocumentsUI - Gitiles

 /*
  * Copyright (C) 2019 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.documentsui.archives;

 import static androidx.core.util.Preconditions.checkArgument;
 import static androidx.core.util.Preconditions.checkNotNull;

 import static com.android.documentsui.archives.ArchiveRegistry.COMMON_ARCHIVE_TYPE;
 import static com.android.documentsui.archives.ArchiveRegistry.SEVEN_Z_TYPE;
 import static com.android.documentsui.archives.ArchiveRegistry.ZIP_TYPE;

 import android.os.FileUtils;
 import android.os.ParcelFileDescriptor;
 import android.text.TextUtils;
 import android.util.Log;

 import androidx.annotation.NonNull;

 import java.io.Closeable;
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.nio.channels.SeekableByteChannel;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.Enumeration;
 import java.util.List;

 import org.apache.commons.compress.archivers.ArchiveEntry;
 import org.apache.commons.compress.archivers.ArchiveException;
 import org.apache.commons.compress.archivers.ArchiveInputStream;
 import org.apache.commons.compress.archivers.ArchiveStreamFactory;
 import org.apache.commons.compress.archivers.sevenz.SevenZFile;
 import org.apache.commons.compress.archivers.zip.ZipArchiveEntry;
 import org.apache.commons.compress.archivers.zip.ZipFile;
 import org.apache.commons.compress.compressors.CompressorException;
 import org.apache.commons.compress.compressors.CompressorStreamFactory;

 /**
  * To handle to all of supported support types of archive or compressed+archive files.
  * @param <T> the archive class such as SevenZFile, ZipFile, ArchiveInputStream etc.
  */
 abstract class ArchiveHandle<T> implements Closeable {
     private static final String TAG = ArchiveHandle.class.getSimpleName();
     /**
      * To re-create the CommonArchive that belongs to SevenZFile, ZipFile, or
      * ArchiveInputStream. It needs file descriptor to create the input stream or seek to the head.
      */
     @NonNull
     private final ParcelFileDescriptor mParcelFileDescriptor;

     /**
      * To re-create the CommonArchive that belongs to SevenZFile, ZipFile, or
      * ArchiveInputStream. It needs MIME type to know how to re-create.
      */
     @NonNull
     private final String mMimeType;

     /**
      * CommonArchive is generic type. It may be SevenZFile, ZipFile, or ArchiveInputStream.
      */
     @NonNull
     private T mCommonArchive;

     /**
      * To use factory pattern ensure the only one way to create the ArchiveHandle instance.
      * @param parcelFileDescriptor the file descriptor
      * @param mimeType the mime type of the file
      * @param commonArchive the common archive instance
      */
     private ArchiveHandle(@NonNull ParcelFileDescriptor parcelFileDescriptor,
                           @NonNull String mimeType,
                           @NonNull T commonArchive) {
         mParcelFileDescriptor = parcelFileDescriptor;
         mMimeType = mimeType;
         mCommonArchive = commonArchive;
     }

     /**
      * It's used to re-create the file input stream. Just like SevenZFile or ArchiveInputStream.
      *
      * @return the file input stream
      */
     @NonNull
     private FileInputStream recreateCommonArchiveStream() throws IOException {
         FileInputStream fileInputStream =
                 new FileInputStream(mParcelFileDescriptor.getFileDescriptor());
         SeekableByteChannel seekableByteChannel = fileInputStream.getChannel();
         seekableByteChannel.position(0);
         return fileInputStream;
     }

     /**
      * To get the MIME type of the file.
      * @return the MIME type of file
      */
     @NonNull
     protected String getMimeType() {
         return mMimeType;
     }

     /**
      * To get the common archive instance.
      *
      * @return the common archive instance.
      */
     @NonNull
     public final T getCommonArchive() {
         return mCommonArchive;
     }

     private void setCommonArchive(@NonNull T commonArchive) {
         mCommonArchive = commonArchive;
     }

     /**
      * Neither SevenZFile nor ArchiveInputStream likes ZipFile that has the API
      * getInputStream(ArchiveEntry), rewind or reset, so it needs to close the
      * current instance and recreate a new one.
      *
      * @param archiveEntry the target entry
      * @return the input stream related to archiveEntry
      * @throws IOException invalid file descriptor may raise the IOException
      * @throws CompressorException invalid compress name may raise the CompressException
      * @throws ArchiveException invalid Archive name may raise the ArchiveException
      */
     protected InputStream getInputStream(@NonNull ArchiveEntry archiveEntry)
             throws IOException, CompressorException, ArchiveException {

         if (!isCommonArchiveSupportGetInputStream()) {
             FileInputStream fileInputStream = recreateCommonArchiveStream();
             T commonArchive = recreateCommonArchive(fileInputStream);
             if (commonArchive != null) {
                 closeCommonArchive();
                 setCommonArchive(commonArchive);
             } else {
                 Log.e(TAG, "new SevenZFile or ArchiveInputStream is null");
                 fileInputStream.close();
             }
         }

         return ArchiveEntryInputStream.create(this, archiveEntry);
     }

     boolean isCommonArchiveSupportGetInputStream() {
         return false;
     }

     void closeCommonArchive() throws IOException {
         throw new UnsupportedOperationException("This kind of ArchiveHandle doesn't support");
     }

     T recreateCommonArchive(FileInputStream fileInputStream)
             throws CompressorException, ArchiveException, IOException {
         throw new UnsupportedOperationException("This kind of ArchiveHandle doesn't support");
     }

     public void close() throws IOException {
         mParcelFileDescriptor.close();
     }

     /**
      * To get the enumeration of all of entries from archive.
      * @return the enumeration of all of entries from archive
      * @throws IOException it may raise the IOException when the archiveHandle get the next entry
      */
     @NonNull
     public abstract Enumeration<? extends ArchiveEntry> getEntries() throws IOException;

     private static class SevenZFileHandle extends ArchiveHandle<SevenZFile> {
         SevenZFileHandle(ParcelFileDescriptor parcelFileDescriptor, String mimeType,
                          SevenZFile commonArchive) {
             super(parcelFileDescriptor, mimeType, commonArchive);
         }

         @Override
         protected void closeCommonArchive() throws IOException {
             getCommonArchive().close();
         }

         @Override
         protected SevenZFile recreateCommonArchive(@NonNull FileInputStream fileInputStream)
                 throws IOException {
             return new SevenZFile(fileInputStream.getChannel());
         }

         @NonNull
         @Override
         public Enumeration<? extends ArchiveEntry> getEntries() {
             if (getCommonArchive().getEntries() == null) {
                 return Collections.emptyEnumeration();
             }

             return Collections.enumeration(
                     (Collection<? extends ArchiveEntry>) getCommonArchive().getEntries());
         }
     }

     private static class ZipFileHandle extends ArchiveHandle<ZipFile> {
         ZipFileHandle(ParcelFileDescriptor parcelFileDescriptor, String mimeType,
                       ZipFile commonArchive) {
             super(parcelFileDescriptor, mimeType, commonArchive);
         }

         @Override
         protected boolean isCommonArchiveSupportGetInputStream() {
             return true;
         }

         @NonNull
         @Override
         public Enumeration<? extends ArchiveEntry> getEntries() {
             final Enumeration<ZipArchiveEntry> enumeration = getCommonArchive().getEntries();
             if (enumeration == null) {
                 return Collections.emptyEnumeration();
             }
             return enumeration;
         }
     }

     private static class CommonArchiveInputHandle extends ArchiveHandle<ArchiveInputStream> {
         CommonArchiveInputHandle(ParcelFileDescriptor parcelFileDescriptor,
                                  String mimeType, ArchiveInputStream commonArchive) {
             super(parcelFileDescriptor, mimeType, commonArchive);
         }

         @Override
         protected void closeCommonArchive() throws IOException {
             getCommonArchive().close();
         }

         @Override
         protected ArchiveInputStream recreateCommonArchive(FileInputStream fileInputStream)
                 throws CompressorException, ArchiveException {
             return createCommonArchive(fileInputStream, getMimeType());
         }

         @NonNull
         @Override
         public Enumeration<? extends ArchiveEntry> getEntries() throws IOException {
             final ArchiveInputStream archiveInputStream = getCommonArchive();
             final List<ArchiveEntry> list = new ArrayList<>();
             ArchiveEntry entry;
             while ((entry = archiveInputStream.getNextEntry()) != null) {
                 list.add(entry);
             }

             return Collections.enumeration(list);
         }
     }

     @NonNull
     private static ArchiveInputStream createCommonArchive(
             @NonNull FileInputStream fileInputStream,
             @NonNull String mimeType) throws CompressorException, ArchiveException {
         InputStream inputStream = fileInputStream;

         String compressName = ArchiveRegistry.getCompressName(mimeType);
         if (!TextUtils.isEmpty(compressName)) {
             CompressorStreamFactory compressorStreamFactory =
                     new CompressorStreamFactory();
             inputStream = compressorStreamFactory
                     .createCompressorInputStream(compressName, inputStream);
         }

         ArchiveStreamFactory archiveStreamFactory = new ArchiveStreamFactory();
         String archiveName = ArchiveRegistry.getArchiveName(mimeType);
         if (TextUtils.isEmpty(archiveName)) {
             throw new ArchiveException("Invalid archive name.");
         }

         return archiveStreamFactory
                 .createArchiveInputStream(archiveName, inputStream);
     }

     /**
      * The only one way creates the instance of ArchiveHandle.
      */
     public static ArchiveHandle create(@NonNull ParcelFileDescriptor parcelFileDescriptor,
             @NonNull String mimeType) throws CompressorException, ArchiveException, IOException {
         checkNotNull(parcelFileDescriptor);
         checkArgument(!TextUtils.isEmpty(mimeType));

         Integer archiveType = ArchiveRegistry.getArchiveType(mimeType);
         if (archiveType == null) {
             throw new UnsupportedOperationException("Doesn't support MIME type " + mimeType);
         }

         FileInputStream fileInputStream =
                 new FileInputStream(parcelFileDescriptor.getFileDescriptor());

         switch (archiveType) {
             case COMMON_ARCHIVE_TYPE:
                 ArchiveInputStream archiveInputStream =
                         createCommonArchive(fileInputStream, mimeType);
                 return new CommonArchiveInputHandle(parcelFileDescriptor, mimeType,
                         archiveInputStream);
             case ZIP_TYPE:
                 SeekableByteChannel zipFileChannel = fileInputStream.getChannel();
                 try {
                     ZipFile zipFile = new ZipFile(zipFileChannel);
                     return new ZipFileHandle(parcelFileDescriptor, mimeType,
                             zipFile);
                 } catch (Exception e) {
                     FileUtils.closeQuietly(zipFileChannel);
                     throw e;
                 }
             case SEVEN_Z_TYPE:
                 SeekableByteChannel sevenZFileChannel = fileInputStream.getChannel();
                 try {
                     SevenZFile sevenZFile = new SevenZFile(sevenZFileChannel);
                     return new SevenZFileHandle(parcelFileDescriptor, mimeType,
                             sevenZFile);
                 } catch (Exception e) {
                     FileUtils.closeQuietly(sevenZFileChannel);
                     throw e;
                 }
             default:
                 throw new UnsupportedOperationException("Doesn't support MIME type "
                         + mimeType);
         }
     }
 }
	/*
	* Copyright (C) 2019 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.documentsui.archives;

	import static androidx.core.util.Preconditions.checkArgument;
	import static androidx.core.util.Preconditions.checkNotNull;

	import static com.android.documentsui.archives.ArchiveRegistry.COMMON_ARCHIVE_TYPE;
	import static com.android.documentsui.archives.ArchiveRegistry.SEVEN_Z_TYPE;
	import static com.android.documentsui.archives.ArchiveRegistry.ZIP_TYPE;

	import android.os.FileUtils;
	import android.os.ParcelFileDescriptor;
	import android.text.TextUtils;
	import android.util.Log;

	import androidx.annotation.NonNull;

	import java.io.Closeable;
	import java.io.FileInputStream;
	import java.io.IOException;
	import java.io.InputStream;
	import java.nio.channels.SeekableByteChannel;
	import java.util.ArrayList;
	import java.util.Collection;
	import java.util.Collections;
	import java.util.Enumeration;
	import java.util.List;

	import org.apache.commons.compress.archivers.ArchiveEntry;
	import org.apache.commons.compress.archivers.ArchiveException;
	import org.apache.commons.compress.archivers.ArchiveInputStream;
	import org.apache.commons.compress.archivers.ArchiveStreamFactory;
	import org.apache.commons.compress.archivers.sevenz.SevenZFile;
	import org.apache.commons.compress.archivers.zip.ZipArchiveEntry;
	import org.apache.commons.compress.archivers.zip.ZipFile;
	import org.apache.commons.compress.compressors.CompressorException;
	import org.apache.commons.compress.compressors.CompressorStreamFactory;

	/**
	* To handle to all of supported support types of archive or compressed+archive files.
	* @param <T> the archive class such as SevenZFile, ZipFile, ArchiveInputStream etc.
	*/
	abstract class ArchiveHandle<T> implements Closeable {
	private static final String TAG = ArchiveHandle.class.getSimpleName();
	/**
	* To re-create the CommonArchive that belongs to SevenZFile, ZipFile, or
	* ArchiveInputStream. It needs file descriptor to create the input stream or seek to the head.
	*/
	@NonNull
	private final ParcelFileDescriptor mParcelFileDescriptor;

	/**
	* To re-create the CommonArchive that belongs to SevenZFile, ZipFile, or
	* ArchiveInputStream. It needs MIME type to know how to re-create.
	*/
	@NonNull
	private final String mMimeType;

	/**
	* CommonArchive is generic type. It may be SevenZFile, ZipFile, or ArchiveInputStream.
	*/
	@NonNull
	private T mCommonArchive;

	/**
	* To use factory pattern ensure the only one way to create the ArchiveHandle instance.
	* @param parcelFileDescriptor the file descriptor
	* @param mimeType the mime type of the file
	* @param commonArchive the common archive instance
	*/
	private ArchiveHandle(@NonNull ParcelFileDescriptor parcelFileDescriptor,
	@NonNull String mimeType,
	@NonNull T commonArchive) {
	mParcelFileDescriptor = parcelFileDescriptor;
	mMimeType = mimeType;
	mCommonArchive = commonArchive;
	}

	/**
	* It's used to re-create the file input stream. Just like SevenZFile or ArchiveInputStream.
	*
	* @return the file input stream
	*/
	@NonNull
	private FileInputStream recreateCommonArchiveStream() throws IOException {
	FileInputStream fileInputStream =
	new FileInputStream(mParcelFileDescriptor.getFileDescriptor());
	SeekableByteChannel seekableByteChannel = fileInputStream.getChannel();
	seekableByteChannel.position(0);
	return fileInputStream;
	}

	/**
	* To get the MIME type of the file.
	* @return the MIME type of file
	*/
	@NonNull
	protected String getMimeType() {
	return mMimeType;
	}

	/**
	* To get the common archive instance.
	*
	* @return the common archive instance.
	*/
	@NonNull
	public final T getCommonArchive() {
	return mCommonArchive;
	}

	private void setCommonArchive(@NonNull T commonArchive) {
	mCommonArchive = commonArchive;
	}

	/**
	* Neither SevenZFile nor ArchiveInputStream likes ZipFile that has the API
	* getInputStream(ArchiveEntry), rewind or reset, so it needs to close the
	* current instance and recreate a new one.
	*
	* @param archiveEntry the target entry
	* @return the input stream related to archiveEntry
	* @throws IOException invalid file descriptor may raise the IOException
	* @throws CompressorException invalid compress name may raise the CompressException
	* @throws ArchiveException invalid Archive name may raise the ArchiveException
	*/
	protected InputStream getInputStream(@NonNull ArchiveEntry archiveEntry)
	throws IOException, CompressorException, ArchiveException {

	if (!isCommonArchiveSupportGetInputStream()) {
	FileInputStream fileInputStream = recreateCommonArchiveStream();
	T commonArchive = recreateCommonArchive(fileInputStream);
	if (commonArchive != null) {
	closeCommonArchive();
	setCommonArchive(commonArchive);
	} else {
	Log.e(TAG, "new SevenZFile or ArchiveInputStream is null");
	fileInputStream.close();
	}
	}

	return ArchiveEntryInputStream.create(this, archiveEntry);
	}

	boolean isCommonArchiveSupportGetInputStream() {
	return false;
	}

	void closeCommonArchive() throws IOException {
	throw new UnsupportedOperationException("This kind of ArchiveHandle doesn't support");
	}

	T recreateCommonArchive(FileInputStream fileInputStream)
	throws CompressorException, ArchiveException, IOException {
	throw new UnsupportedOperationException("This kind of ArchiveHandle doesn't support");
	}

	public void close() throws IOException {
	mParcelFileDescriptor.close();
	}

	/**
	* To get the enumeration of all of entries from archive.
	* @return the enumeration of all of entries from archive
	* @throws IOException it may raise the IOException when the archiveHandle get the next entry
	*/
	@NonNull
	public abstract Enumeration<? extends ArchiveEntry> getEntries() throws IOException;

	private static class SevenZFileHandle extends ArchiveHandle<SevenZFile> {
	SevenZFileHandle(ParcelFileDescriptor parcelFileDescriptor, String mimeType,
	SevenZFile commonArchive) {
	super(parcelFileDescriptor, mimeType, commonArchive);
	}

	@Override
	protected void closeCommonArchive() throws IOException {
	getCommonArchive().close();
	}

	@Override
	protected SevenZFile recreateCommonArchive(@NonNull FileInputStream fileInputStream)
	throws IOException {
	return new SevenZFile(fileInputStream.getChannel());
	}

	@NonNull
	@Override
	public Enumeration<? extends ArchiveEntry> getEntries() {
	if (getCommonArchive().getEntries() == null) {
	return Collections.emptyEnumeration();
	}

	return Collections.enumeration(
	(Collection<? extends ArchiveEntry>) getCommonArchive().getEntries());
	}
	}

	private static class ZipFileHandle extends ArchiveHandle<ZipFile> {
	ZipFileHandle(ParcelFileDescriptor parcelFileDescriptor, String mimeType,
	ZipFile commonArchive) {
	super(parcelFileDescriptor, mimeType, commonArchive);
	}

	@Override
	protected boolean isCommonArchiveSupportGetInputStream() {
	return true;
	}

	@NonNull
	@Override
	public Enumeration<? extends ArchiveEntry> getEntries() {
	final Enumeration<ZipArchiveEntry> enumeration = getCommonArchive().getEntries();
	if (enumeration == null) {
	return Collections.emptyEnumeration();
	}
	return enumeration;
	}
	}

	private static class CommonArchiveInputHandle extends ArchiveHandle<ArchiveInputStream> {
	CommonArchiveInputHandle(ParcelFileDescriptor parcelFileDescriptor,
	String mimeType, ArchiveInputStream commonArchive) {
	super(parcelFileDescriptor, mimeType, commonArchive);
	}

	@Override
	protected void closeCommonArchive() throws IOException {
	getCommonArchive().close();
	}

	@Override
	protected ArchiveInputStream recreateCommonArchive(FileInputStream fileInputStream)
	throws CompressorException, ArchiveException {
	return createCommonArchive(fileInputStream, getMimeType());
	}

	@NonNull
	@Override
	public Enumeration<? extends ArchiveEntry> getEntries() throws IOException {
	final ArchiveInputStream archiveInputStream = getCommonArchive();
	final List<ArchiveEntry> list = new ArrayList<>();
	ArchiveEntry entry;
	while ((entry = archiveInputStream.getNextEntry()) != null) {
	list.add(entry);
	}

	return Collections.enumeration(list);
	}
	}

	@NonNull
	private static ArchiveInputStream createCommonArchive(
	@NonNull FileInputStream fileInputStream,
	@NonNull String mimeType) throws CompressorException, ArchiveException {
	InputStream inputStream = fileInputStream;

	String compressName = ArchiveRegistry.getCompressName(mimeType);
	if (!TextUtils.isEmpty(compressName)) {
	CompressorStreamFactory compressorStreamFactory =
	new CompressorStreamFactory();
	inputStream = compressorStreamFactory
	.createCompressorInputStream(compressName, inputStream);
	}

	ArchiveStreamFactory archiveStreamFactory = new ArchiveStreamFactory();
	String archiveName = ArchiveRegistry.getArchiveName(mimeType);
	if (TextUtils.isEmpty(archiveName)) {
	throw new ArchiveException("Invalid archive name.");
	}

	return archiveStreamFactory
	.createArchiveInputStream(archiveName, inputStream);
	}

	/**
	* The only one way creates the instance of ArchiveHandle.
	*/
	public static ArchiveHandle create(@NonNull ParcelFileDescriptor parcelFileDescriptor,
	@NonNull String mimeType) throws CompressorException, ArchiveException, IOException {
	checkNotNull(parcelFileDescriptor);
	checkArgument(!TextUtils.isEmpty(mimeType));

	Integer archiveType = ArchiveRegistry.getArchiveType(mimeType);
	if (archiveType == null) {
	throw new UnsupportedOperationException("Doesn't support MIME type " + mimeType);
	}

	FileInputStream fileInputStream =
	new FileInputStream(parcelFileDescriptor.getFileDescriptor());

	switch (archiveType) {
	case COMMON_ARCHIVE_TYPE:
	ArchiveInputStream archiveInputStream =
	createCommonArchive(fileInputStream, mimeType);
	return new CommonArchiveInputHandle(parcelFileDescriptor, mimeType,
	archiveInputStream);
	case ZIP_TYPE:
	SeekableByteChannel zipFileChannel = fileInputStream.getChannel();
	try {
	ZipFile zipFile = new ZipFile(zipFileChannel);
	return new ZipFileHandle(parcelFileDescriptor, mimeType,
	zipFile);
	} catch (Exception e) {
	FileUtils.closeQuietly(zipFileChannel);
	throw e;
	}
	case SEVEN_Z_TYPE:
	SeekableByteChannel sevenZFileChannel = fileInputStream.getChannel();
	try {
	SevenZFile sevenZFile = new SevenZFile(sevenZFileChannel);
	return new SevenZFileHandle(parcelFileDescriptor, mimeType,
	sevenZFile);
	} catch (Exception e) {
	FileUtils.closeQuietly(sevenZFileChannel);
	throw e;
	}
	default:
	throw new UnsupportedOperationException("Doesn't support MIME type "
	+ mimeType);
	}
	}
	}