/**
* Parse a repository document.
*
* @param url
* @throws IOException
* @throws XmlPullParserException
* @throws Exception
*/
void parseDocument(URL url) throws IOException, XmlPullParserException, Exception {
if (!visited.contains(url)) {
visited.add(url);
try {
System.out.println("Visiting: " + url);
InputStream in = null;
if (url.getPath().endsWith(".zip")) {
ZipInputStream zin = new ZipInputStream(url.openStream());
ZipEntry entry = zin.getNextEntry();
while (entry != null) {
if (entry.getName().equals("repository.xml")) {
in = zin;
break;
}
entry = zin.getNextEntry();
}
} else {
in = url.openStream();
}
Reader reader = new InputStreamReader(in);
XmlPullParser parser = new KXmlParser();
parser.setInput(reader);
parseRepository(parser);
} catch (MalformedURLException e) {
System.out.println("Cannot create connection to url");
}
}
}
private void removePreviousModVersion(String modName, String installedVersion) {
try {
// Mod has been previously installed uninstall previous version
File previousModZip = new File(cacheDir, modName + "-" + installedVersion + ".zip");
ZipFile zf = new ZipFile(previousModZip);
Enumeration<? extends ZipEntry> entries = zf.entries();
// Go through zipfile of previous version and delete all file from
// Modpack that exist in the zip
while (entries.hasMoreElements()) {
ZipEntry entry = entries.nextElement();
if (entry.isDirectory()) {
continue;
}
File file = new File(GameUpdater.modpackDir, entry.getName());
Util.log("Deleting '%s'", entry.getName());
if (file.exists()) {
// File from mod exists.. delete it
file.delete();
}
}
InstalledModsYML.removeMod(modName);
} catch (IOException e) {
e.printStackTrace();
}
}
private void checkLoadedModForPermissionClass(File modFile) {
try {
Pattern p = Pattern.compile("permission", Pattern.CASE_INSENSITIVE);
if (modFile.isDirectory()) {
for (File file : modFile.listFiles()) {
checkLoadedModForPermissionClass(file);
}
} else if ((modFile.getName().endsWith(".zip")) || (modFile.getName().endsWith(".jar"))) {
ZipFile zip = new ZipFile(modFile);
Enumeration entries = zip.entries();
while (entries.hasMoreElements()) {
ZipEntry zipentry = (ZipEntry) entries.nextElement();
if (zipentry != null
&& zipentry.getName().endsWith(".class")
&& p.matcher(zipentry.getName()).find()) {
checkLoadedClass(zip.getInputStream(zipentry));
}
}
zip.close();
} else if (modFile.getName().endsWith(".class") && p.matcher(modFile.getName()).find()) {
checkLoadedClass(new FileInputStream(modFile));
}
} catch (IOException e) {
}
}
/* @see loci.formats.FormatReader#initFile(String) */
protected void initFile(String id) throws FormatException, IOException {
super.initFile(id);
reader = new ImageReader();
reader.setMetadataOptions(getMetadataOptions());
reader.setMetadataFiltered(isMetadataFiltered());
reader.setOriginalMetadataPopulated(isOriginalMetadataPopulated());
reader.setNormalized(isNormalized());
reader.setMetadataStore(getMetadataStore());
// NB: We need a raw handle on the ZIP data itself, not a ZipHandle.
IRandomAccess rawHandle = Location.getHandle(id, false, false);
in = new RandomAccessInputStream(rawHandle, id);
ZipInputStream zip = new ZipInputStream(in);
while (true) {
ZipEntry ze = zip.getNextEntry();
if (ze == null) break;
ZipHandle handle = new ZipHandle(id, ze);
Location.mapFile(ze.getName(), handle);
mappedFiles.add(ze.getName());
}
ZipHandle base = new ZipHandle(id);
reader.setId(base.getEntryName());
metadataStore = reader.getMetadataStore();
core = reader.getCoreMetadata();
metadata = reader.getGlobalMetadata();
base.close();
}
/**
* Unzips entries from {@code stream} into {@code directory}.
*
* @param stream source zip stream
* @param directory target directory to which entries going to be unzipped.
* @param buffer the buffer to use
* @throws IOException if an I/O error occurs.
*/
public static void unzip(final ZipInputStream stream, final File directory, final byte[] buffer)
throws IOException {
if (stream == null) {
throw new NullPointerException("stream");
}
if (directory == null) {
throw new NullPointerException("directory");
}
if (!directory.isDirectory()) {
throw new IllegalArgumentException("directory doesn't exist");
}
if (buffer == null) {
throw new NullPointerException("buffer");
}
if (buffer.length == 0) {
throw new IllegalArgumentException("buffer.length(" + buffer.length + ") == 0");
}
ZipEntry entry;
while ((entry = stream.getNextEntry()) != null) {
final File file = file(directory, entry);
if (!entry.isDirectory()) {
ByteStreams.copy(stream, file, buffer, -1L);
}
stream.closeEntry();
}
}
@Override
public String getScript() throws IOException {
ZipInputStream zippedIn = null;
try {
zippedIn = new ZipInputStream(new FileInputStream(getZipFile()));
ZipEntry entry;
while ((entry = zippedIn.getNextEntry()) != null) {
if (entry.getName().equals(getEntryName())) {
break;
}
}
if (entry == null) {
throw new OpenGammaRuntimeException(
"No entry found in zip file " + getZipFile() + " with name " + getEntryName());
}
return IOUtils.toString(zippedIn);
} catch (FileNotFoundException e) {
throw new OpenGammaRuntimeException("Zip file not found: " + getZipFile());
} catch (IOException e) {
throw new OpenGammaRuntimeException("Error reading from zip file: " + getZipFile());
} finally {
if (zippedIn != null) {
try {
zippedIn.close();
} catch (IOException e) {
}
}
}
}
protected void unpackComponents() throws IOException, FileNotFoundException {
File applicationPackage = new File(getApplication().getPackageResourcePath());
File componentsDir = new File(sGREDir, "components");
if (componentsDir.lastModified() == applicationPackage.lastModified()) return;
componentsDir.mkdir();
componentsDir.setLastModified(applicationPackage.lastModified());
GeckoAppShell.killAnyZombies();
ZipFile zip = new ZipFile(applicationPackage);
byte[] buf = new byte[32768];
try {
if (unpackFile(zip, buf, null, "removed-files")) removeFiles();
} catch (Exception ex) {
// This file may not be there, so just log any errors and move on
Log.w(LOG_FILE_NAME, "error removing files", ex);
}
// copy any .xpi file into an extensions/ directory
Enumeration<? extends ZipEntry> zipEntries = zip.entries();
while (zipEntries.hasMoreElements()) {
ZipEntry entry = zipEntries.nextElement();
if (entry.getName().startsWith("extensions/") && entry.getName().endsWith(".xpi")) {
Log.i("GeckoAppJava", "installing extension : " + entry.getName());
unpackFile(zip, buf, entry, entry.getName());
}
}
}
/**
* extracts class files from jar/zip archive to specified path. See <code>IDecompiler</code>
* documentation for the format of pareameters.
*/
public static void extract(
String archivePath, String packege, String className, boolean inner, String to)
throws IOException {
ZipFile archive = new ZipFile(archivePath);
List entries = findRelevant(archive, packege, className, inner);
InputStream in = null;
OutputStream out = null;
byte[] buffer = new byte[2048];
ZipEntry entry;
String outFile;
int lastSep, amountRead;
for (int i = 0; i < entries.size(); i++) {
entry = (ZipEntry) entries.get(i);
outFile = entry.getName();
if ((lastSep = outFile.lastIndexOf('/')) != -1) outFile = outFile.substring(lastSep);
try {
in = archive.getInputStream(entry);
if (in == null) throw new IOException("Zip file entry <" + entry.getName() + "> not found");
out = new FileOutputStream(to + File.separator + outFile);
while ((amountRead = in.read(buffer)) != -1) out.write(buffer, 0, amountRead);
} finally {
if (in != null) in.close();
if (out != null) out.close();
}
}
}
private void addExportedPackages(Set allpackages, ArrayList instructions, File file)
throws ZipException, IOException {
if (file.isDirectory()) {
DirectoryScanner ds = new DirectoryScanner();
ds.setBasedir(file);
ds.setIncludes(new String[] {"**"});
ds.scan();
String[] files = ds.getIncludedFiles();
for (int i = 0; i < files.length; i++) {
String pkg = getPackage(files[i]);
if (pkg != null && !excluded(instructions, pkg)) {
allpackages.add(pkg);
}
}
} else {
ZipFile zip = new ZipFile(file);
try {
Enumeration entries = zip.entries();
while (entries.hasMoreElements()) {
ZipEntry entry = (ZipEntry) entries.nextElement();
String pkg = getPackage(entry.getName());
if (pkg != null && !excluded(instructions, pkg)) {
allpackages.add(pkg);
}
}
} finally {
zip.close();
}
}
}
public static boolean unpackFileFromZip(Path zipfile, String filename, Path destDirectory)
throws IOException {
boolean ret = true;
byte[] bytebuffer = new byte[BUFFERSIZE];
ZipInputStream zipinputstream = new ZipInputStream(new FileInputStream(zipfile.toFile()));
ZipEntry zipentry;
while ((zipentry = zipinputstream.getNextEntry()) != null) {
if (zipentry.getName().equals(filename)) {
Path newFile = destDirectory.resolve(zipentry.getName());
FileOutputStream fileoutputstream = new FileOutputStream(newFile.toFile());
int bytes;
while ((bytes = zipinputstream.read(bytebuffer)) > -1) {
fileoutputstream.write(bytebuffer, 0, bytes);
}
fileoutputstream.close();
zipinputstream.closeEntry();
zipinputstream.close();
return ret;
}
zipinputstream.closeEntry();
}
zipinputstream.close();
return ret;
}
static boolean unpackZipTo(Path zipfile, Path destDirectory) throws IOException {
boolean ret = true;
byte[] bytebuffer = new byte[BUFFERSIZE];
ZipInputStream zipinputstream = new ZipInputStream(new FileInputStream(zipfile.toFile()));
ZipEntry zipentry;
while ((zipentry = zipinputstream.getNextEntry()) != null) {
Path newFile = destDirectory.resolve(zipentry.getName());
if (!Files.exists(newFile.getParent(), LinkOption.NOFOLLOW_LINKS)) {
Files.createDirectories(newFile.getParent());
}
if (!Files.isDirectory(newFile, LinkOption.NOFOLLOW_LINKS)) {
FileOutputStream fileoutputstream = new FileOutputStream(newFile.toFile());
int bytes;
while ((bytes = zipinputstream.read(bytebuffer)) > -1) {
fileoutputstream.write(bytebuffer, 0, bytes);
}
fileoutputstream.close();
}
zipinputstream.closeEntry();
}
zipinputstream.close();
return ret;
}
/** Разархивация файла с БД */
private void dearchiveDB() {
String zipFile = RES_ABS_PATH + File.separator + DB_ARCHIVE_NAME;
String outputFolder = RES_ABS_PATH;
try {
ZipInputStream zis = new ZipInputStream(new FileInputStream(zipFile));
ZipEntry ze = zis.getNextEntry();
while (ze != null) {
String fileName = ze.getName();
File newFile = new File(outputFolder + File.separator + fileName);
System.out.println("File unzip : " + newFile.getAbsoluteFile());
new File(newFile.getParent()).mkdirs();
FileOutputStream fos = new FileOutputStream(newFile);
int len;
byte[] buffer = new byte[1024];
while ((len = zis.read(buffer)) > 0) {
fos.write(buffer, 0, len);
}
fos.close();
ze = zis.getNextEntry();
}
zis.closeEntry();
zis.close();
System.out.println("File unziped");
} catch (IOException ex) {
ex.printStackTrace();
}
}
/**
* Unzip an archive
*
* @param zipname the archive name, stored in the temp directory
* @return boolean state indicating the unzip success
*/
private boolean UnzipLangArchive(String zipname) {
ZipFile zipFile;
// reset the statuses, thus we will be able to get the progress[%] status
m_lMaxDownloadSz = GetZipSize(zipname);
m_lCurrentDownloadSz = 0;
try {
zipFile = new ZipFile(zipname);
Enumeration entries = zipFile.entries();
while (entries.hasMoreElements()) {
ZipEntry entry = (ZipEntry) entries.nextElement();
String filename = entry.getName();
Log.v(TAG, "Extracting file: " + filename);
if (!CopyInputStream(zipFile.getInputStream(entry), entry.getSize(), entry.getName()))
return false;
m_ParentProgressDialog.setProgress(GetDownloadStatus());
}
zipFile.close();
} catch (IOException ioe) {
Log.v(TAG, "exception:" + ioe.toString());
return false;
}
return true;
}
public static void unZip(String unZipfileName, String mDestPath) {
if (!mDestPath.endsWith("/")) {
mDestPath = mDestPath + "/";
}
FileOutputStream fileOut = null;
ZipInputStream zipIn = null;
ZipEntry zipEntry = null;
File file = null;
int readedBytes = 0;
byte buf[] = new byte[4096];
try {
zipIn = new ZipInputStream(new BufferedInputStream(new FileInputStream(unZipfileName)));
while ((zipEntry = zipIn.getNextEntry()) != null) {
file = new File(mDestPath + zipEntry.getName());
if (zipEntry.isDirectory()) {
file.mkdirs();
} else {
// 如果指定文件的目录不存在,则创建之.
File parent = file.getParentFile();
if (!parent.exists()) {
parent.mkdirs();
}
fileOut = new FileOutputStream(file);
while ((readedBytes = zipIn.read(buf)) > 0) {
fileOut.write(buf, 0, readedBytes);
}
fileOut.close();
}
zipIn.closeEntry();
}
} catch (IOException ioe) {
ioe.printStackTrace();
}
}
@Override
public Item item(final QueryContext qc, final InputInfo ii) throws QueryException {
checkCreate(qc);
final Path path = toPath(0, qc);
final B64 archive = toB64(exprs[1], qc, false);
final TokenSet hs = entries(2, qc);
try (ArchiveIn in = ArchiveIn.get(archive.input(info), info)) {
while (in.more()) {
final ZipEntry ze = in.entry();
final String name = ze.getName();
if (hs == null || hs.delete(token(name)) != 0) {
final Path file = path.resolve(name);
if (ze.isDirectory()) {
Files.createDirectories(file);
} else {
Files.createDirectories(file.getParent());
Files.write(file, in.read());
}
}
}
} catch (final IOException ex) {
throw ARCH_FAIL_X.get(info, ex);
}
return null;
}
static ArrayList<String> getZipFileEntryNames(ZipFile z) {
ArrayList<String> out = new ArrayList<String>();
for (ZipEntry ze : Collections.list(z.entries())) {
out.add(ze.getName());
}
return out;
}
/**
* Unzip given file into given folder.
*
* @param fileZip : zip file to unzip.
* @param dirOut : folder where to put the unzipped files.
*/
public static void unzip(File fileZip, File dirOut) {
try {
byte[] buf = new byte[10 * 1024];
if (!fileZip.canRead()) throw new IllegalArgumentException(fileZip.getAbsolutePath());
if (!dirOut.isDirectory()) dirOut.mkdirs();
if (!dirOut.isDirectory()) throw new IllegalArgumentException(dirOut.getAbsolutePath());
FileInputStream fin = new FileInputStream(fileZip);
ZipInputStream zin = new ZipInputStream(fin);
ZipEntry ze = null;
while ((ze = zin.getNextEntry()) != null) {
File fileZe = new File(dirOut, ze.getName());
Log.i("Zip", fileZe.getAbsolutePath());
if (ze.isDirectory()) continue;
assureParentExists(fileZe);
BufferedOutputStream fout = new BufferedOutputStream(new FileOutputStream(fileZe));
while (true) {
int read = zin.read(buf);
if (-1 == read) break; // End of file.
fout.write(buf, 0, read);
}
zin.closeEntry();
fout.close();
}
zin.close();
} catch (Exception e) {
Log.e("MyZip", "unzip", e);
}
}
@Test
public void packingALargeFileShouldGenerateTheSameOutputWhenOverwritingAsWhenAppending()
throws IOException {
File reference = File.createTempFile("reference", ".zip");
String packageName = getClass().getPackage().getName().replace(".", "/");
URL sample = Resources.getResource(packageName + "/macbeth.properties");
byte[] input = Resources.toByteArray(sample);
try (CustomZipOutputStream out = ZipOutputStreams.newOutputStream(output, OVERWRITE_EXISTING);
ZipOutputStream ref = new ZipOutputStream(new FileOutputStream(reference))) {
CustomZipEntry entry = new CustomZipEntry("macbeth.properties");
entry.setTime(System.currentTimeMillis());
out.putNextEntry(entry);
ref.putNextEntry(entry);
out.write(input);
ref.write(input);
}
byte[] seen = Files.readAllBytes(output);
byte[] expected = Files.readAllBytes(reference.toPath());
// Make sure the output is valid.
try (ZipInputStream in = new ZipInputStream(Files.newInputStream(output))) {
ZipEntry entry = in.getNextEntry();
assertEquals("macbeth.properties", entry.getName());
assertNull(in.getNextEntry());
}
assertArrayEquals(expected, seen);
}
public static void registerModInJar(String modid, File jar) {
try {
ZipFile zipfile = new ZipFile(jar);
Enumeration enumeration = zipfile.entries();
while (enumeration.hasMoreElements()) {
ZipEntry zipentry = (ZipEntry) enumeration.nextElement();
String fileName = zipentry.getName();
Path path1 = Paths.get(fileName);
Path path2 = Paths.get("assets", modid, "books");
if (path1.startsWith(path2)) {
try {
String json = IOUtils.toString(zipfile.getInputStream(zipentry));
BookData data =
BookRegistry.register(GsonClientHelper.getGson().fromJson(json, BookData.class));
ELogger.log(
Level.INFO,
"Successfully loaded in the book with the unique identifier: "
+ data.uniqueName
+ " for the language: "
+ data.language);
} catch (Exception e) {
e.printStackTrace();
}
}
}
zipfile.close();
} catch (Exception e) {
}
}
static Hashtable<String, PkgEntry> readJarFile(InputStream in) {
Hashtable<String, PkgEntry> tbl = new Hashtable<String, PkgEntry>();
try {
ZipInputStream zis = new ZipInputStream(in);
ZipEntry ze = zis.getNextEntry();
while (ze != null) {
String zname = ze.getName();
if (zname.endsWith(".class")) {
String pkgname = getPackageName(zname);
if (!tbl.containsKey(pkgname)) {
long csize = getCompressedSize(zis);
tbl.put(pkgname, new PkgEntry(ze.getSize(), csize));
} else {
PkgEntry pe = tbl.get(pkgname);
long csize = getCompressedSize(zis);
pe.addSizes(ze.getSize(), csize);
tbl.put(pkgname, pe);
}
}
ze = zis.getNextEntry();
}
} catch (ZipException ex) {
Logger.getLogger(JarAnalyzer.class.getName()).log(Level.SEVERE, null, ex);
} catch (IOException ex) {
Logger.getLogger(JarAnalyzer.class.getName()).log(Level.SEVERE, null, ex);
}
return tbl;
}
private boolean unpackFile(ZipFile zip, byte[] buf, ZipEntry fileEntry, String name)
throws IOException, FileNotFoundException {
if (fileEntry == null) fileEntry = zip.getEntry(name);
if (fileEntry == null)
throw new FileNotFoundException("Can't find " + name + " in " + zip.getName());
File outFile = new File(sGREDir, name);
if (outFile.lastModified() == fileEntry.getTime() && outFile.length() == fileEntry.getSize())
return false;
File dir = outFile.getParentFile();
if (!dir.exists()) dir.mkdirs();
InputStream fileStream;
fileStream = zip.getInputStream(fileEntry);
OutputStream outStream = new FileOutputStream(outFile);
while (fileStream.available() > 0) {
int read = fileStream.read(buf, 0, buf.length);
outStream.write(buf, 0, read);
}
fileStream.close();
outStream.close();
outFile.setLastModified(fileEntry.getTime());
return true;
}
public static LinkedHashMap readJarFileEntries(File jarFile) throws Exception {
LinkedHashMap entries = new LinkedHashMap();
JarFile jarFileWrapper = null;
if (jarFile != null) {
logger.debug("Reading jar entries from " + jarFile.getAbsolutePath());
try {
jarFileWrapper = new JarFile(jarFile);
Enumeration iter = jarFileWrapper.entries();
while (iter.hasMoreElements()) {
ZipEntry zipEntry = (ZipEntry) iter.nextElement();
InputStream entryStream = jarFileWrapper.getInputStream(zipEntry);
ByteArrayOutputStream byteArrayStream = new ByteArrayOutputStream();
try {
IOUtils.copy(entryStream, byteArrayStream);
entries.put(zipEntry.getName(), byteArrayStream.toByteArray());
logger.debug(
"Read jar entry " + zipEntry.getName() + " from " + jarFile.getAbsolutePath());
} finally {
byteArrayStream.close();
}
}
} finally {
if (jarFileWrapper != null) {
try {
jarFileWrapper.close();
} catch (Exception ignore) {
logger.debug(ignore);
}
}
}
}
return entries;
}
/**
* Get the preview image of a ggb file.
*
* @param file
* @throws IOException
* @return
*/
public static final BufferedImage getPreviewImage(File file) throws IOException {
// just allow preview images for ggb files
if (!file.getName().endsWith(".ggb")) {
throw new IllegalArgumentException("Preview image source file has to be of the type .ggb");
}
FileInputStream fis = new FileInputStream(file);
ZipInputStream zip = new ZipInputStream(fis);
BufferedImage result = null;
// get all entries from the zip archive
while (true) {
ZipEntry entry = zip.getNextEntry();
if (entry == null) break;
if (entry.getName().equals(XML_FILE_THUMBNAIL)) {
result = ImageIO.read(zip);
break;
}
// get next entry
zip.closeEntry();
}
zip.close();
fis.close();
return result;
}
/**
* @return a mutable list
* @throws IOException
*/
public static List<JSSourceFile> getDefaultExterns() throws IOException {
InputStream input = CommandLineRunner.class.getResourceAsStream("/externs.zip");
ZipInputStream zip = new ZipInputStream(input);
Map<String, JSSourceFile> externsMap = Maps.newHashMap();
for (ZipEntry entry = null; (entry = zip.getNextEntry()) != null; ) {
LimitInputStream entryStream = new LimitInputStream(zip, entry.getSize());
externsMap.put(
entry.getName(),
JSSourceFile.fromInputStream(
// Give the files an odd prefix, so that they do not conflict
// with the user's files.
"externs.zip//" + entry.getName(), entryStream));
}
Preconditions.checkState(
externsMap.keySet().equals(Sets.newHashSet(DEFAULT_EXTERNS_NAMES)),
"Externs zip must match our hard-coded list of externs.");
// Order matters, so the resources must be added to the result list
// in the expected order.
List<JSSourceFile> externs = Lists.newArrayList();
for (String key : DEFAULT_EXTERNS_NAMES) {
externs.add(externsMap.get(key));
}
return externs;
}
protected static File file(final File root, final ZipEntry entry) throws IOException {
if (root == null) {
throw new NullPointerException("root");
}
if (!root.isDirectory()) {
throw new IllegalArgumentException("root is not an existing directory");
}
if (entry == null) {
throw new NullPointerException("entry");
}
final File file = new File(root, entry.getName());
File parent = file;
if (!entry.isDirectory()) {
final String name = entry.getName();
final int index = name.lastIndexOf('/');
if (index != -1) {
parent = new File(root, name.substring(0, index));
}
}
if (parent != null && !parent.isDirectory() && !parent.mkdirs()) {
throw new IOException("failed to create a directory: " + parent.getPath());
}
return file;
}
public static boolean isJarDirectory(String path) {
if (isJarFile()) {
try {
JarFile jar = new JarFile(getJarFile());
ZipEntry entry = jar.getEntry(path);
return entry != null && entry.isDirectory();
} catch (Exception e) {
e.printStackTrace();
}
} else {
try {
URL url = FileUtilities.class.getResource("/" + path);
if (url != null) {
URI uri = url.toURI();
File classpath = new File(uri);
return classpath.isDirectory();
} else {
return false;
}
} catch (Exception e) {
e.printStackTrace();
}
}
return false;
}
/**
* Reads all files into byte arrays. Here we don't know whether the ZIP file is valid.
*
* <p>The ZIP file is valid when contains a 'manifest.json' file and all BIN and DAT files that
* are specified in the manifest.
*
* <p>For backwards compatibility ArchiveInputStream supports also ZIP archives without
* 'manifest.json' file but than it MUST include at least one of the following files:
* softdevice.bin/hex, bootloader.bin/hex, application.bin/hex. To support the init packet such
* ZIP file should contain also application.dat and/or system.dat (with the CRC16 of a SD, BL or
* SD+BL together).
*/
private void parseZip(int mbrSize) throws IOException {
final byte[] buffer = new byte[1024];
String manifestData = null;
ZipEntry ze;
while ((ze = getNextEntry()) != null) {
final String filename = ze.getName();
// Read file content to byte array
final ByteArrayOutputStream baos = new ByteArrayOutputStream();
int count;
while ((count = super.read(buffer)) != -1) {
baos.write(buffer, 0, count);
}
byte[] source = baos.toByteArray();
// In case of HEX file convert it to BIN
if (filename.toLowerCase(Locale.US).endsWith("hex")) {
final HexInputStream is = new HexInputStream(source, mbrSize);
source = new byte[is.available()];
is.read(source);
is.close();
}
// Save the file content either as a manifest data or by adding it to entries
if (MANIFEST.equals(filename)) manifestData = new String(source, "UTF-8");
else entries.put(filename, source);
}
if (manifestData != null) {
final ManifestFile manifestFile = new Gson().fromJson(manifestData, ManifestFile.class);
manifest = manifestFile.getManifest();
}
}
/**
* Extracts all files from a zip to disk.
*
* @param zip data (zip format)
* @throws IOException
*/
private void extractZip(byte[] zip) throws IOException {
ZipInputStream zis = null;
try {
ByteArrayInputStream bais = new ByteArrayInputStream(zip);
zis = new ZipInputStream(new BufferedInputStream(bais));
ZipEntry ze = null;
// extract all entries
Log.d(TAG, "Start extracting backup.");
int i = 0;
while ((ze = zis.getNextEntry()) != null) {
if (!shouldIgnoreZipEntry(ze)) {
extractFromZipAndSaveToFile(zis, ze);
++i;
} else {
Log.d(TAG, "Ignore entry: " + ze.getName());
}
}
Log.i(TAG, "Extracted " + i + " elements from backup.");
} finally {
if (zis != null) {
try {
zis.close();
} catch (IOException e) {
Log.w(TAG, "Could not close zip input stream.", e);
}
}
}
}
/**
* Copies your database from your local assets-folder to the just created empty database in the
* system folder, from where it can be accessed and handled. This is done by transfering
* bytestream.
*/
private void copyDataBase() throws IOException {
Log.d(TAG, "copyDataBase() called with: " + "");
// Open your local db as the input stream
ZipInputStream zipInputStream =
new ZipInputStream(context.getAssets().open("data/" + DATABASE_NAME + ".zip"));
ZipEntry entry;
do {
entry = zipInputStream.getNextEntry();
} while (!entry.getName().equals(DATABASE_NAME));
// InputStream myInput = context.getAssets().open(DATABASE_NAME);
// Path to the just created empty db
String outFileName = DATABASE_PATH + DATABASE_NAME;
// Open the empty db as the output stream
OutputStream myOutput = new FileOutputStream(outFileName);
// transfer bytes from the inputfile to the outputfile
byte[] buffer = new byte[1024];
int length;
while ((length = zipInputStream.read(buffer)) > 0) {
myOutput.write(buffer, 0, length);
}
// Close the streams
myOutput.flush();
myOutput.close();
zipInputStream.close();
}
private byte[] createMultiLevelArchive(List<String> resources, String archivePath)
throws IOException {
try (ByteArrayOutputStream buffer = new ByteArrayOutputStream()) {
try (ZipOutputStream out = new ZipOutputStream(buffer)) {
for (String resourcePath : resources) {
ZipEntry entry = new ZipEntry(resourcePath);
entry.setLastModifiedTime(time);
out.putNextEntry(entry);
try (InputStream in = getResourceAsStream(resourcePath)) {
StreamUtils.copyStream(in, out);
}
out.closeEntry();
}
ZipEntry entry = new ZipEntry("test/");
entry.setLastModifiedTime(time);
out.putNextEntry(entry);
out.closeEntry();
entry = new ZipEntry(archivePath);
entry.setLastModifiedTime(time);
out.putNextEntry(entry);
try (InputStream in = new ByteArrayInputStream(createArchive(resources))) {
StreamUtils.copyStream(in, out);
}
out.closeEntry();
}
return buffer.toByteArray();
}
}
