Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* ProGuard -- shrinking, optimization, obfuscation, and preverification
* of Java bytecode.
*
* Copyright (c) 2002-2019 Guardsquare NV
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the Free
* Software Foundation; either version 2 of the License, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
package proguard;
import proguard.classfile.*;
import proguard.io.*;
import proguard.util.*;
import static proguard.DataEntryReaderFactory.getFilterExcludingVersionedClasses;
import java.util.List;
/**
* This class can create DataEntryWriter instances based on class paths. The
* writers will wrap the output in the proper apks, jars, wars, ears, jmods,
* and zips.
*
* @author Eric Lafortune
*/
public class DataEntryWriterFactory
{
private final ClassPool programClassPool;
private final MultiValueMap extraClassNameMap;
/**
* Creates a new DataEntryWriterFactory with the given parameters.
* @param programClassPool the program classpool to process.
*/
public DataEntryWriterFactory(ClassPool programClassPool,
MultiValueMap extraClassNamemap)
{
this.programClassPool = programClassPool;
this.extraClassNameMap = extraClassNamemap;
}
/**
* Creates a DataEntryWriter that can write to the given class path entries.
*
* @param classPath the output class path.
* @param fromIndex the start index in the class path.
* @param toIndex the end index in the class path.
* @return a DataEntryWriter for writing to the given class path entries.
*/
public DataEntryWriter createDataEntryWriter(ClassPath classPath,
int fromIndex,
int toIndex)
{
DataEntryWriter writer = null;
// Create a chain of writers, one for each class path entry.
for (int index = toIndex - 1; index >= fromIndex; index--)
{
ClassPathEntry entry = classPath.get(index);
writer = createClassPathEntryWriter(entry, writer);
}
return writer;
}
/**
* Creates a DataEntryWriter that can write to the given class path entry,
* or delegate to another DataEntryWriter if its filters don't match.
*/
private DataEntryWriter createClassPathEntryWriter(ClassPathEntry classPathEntry,
DataEntryWriter alternativeWriter)
{
boolean isApk = classPathEntry.isApk();
boolean isJar = classPathEntry.isJar();
boolean isAar = classPathEntry.isAar();
boolean isWar = classPathEntry.isWar();
boolean isEar = classPathEntry.isEar();
boolean isJmod = classPathEntry.isJmod();
boolean isZip = classPathEntry.isZip();
List filter = getFilterExcludingVersionedClasses(classPathEntry);
List apkFilter = classPathEntry.getApkFilter();
List jarFilter = classPathEntry.getJarFilter();
List aarFilter = classPathEntry.getAarFilter();
List warFilter = classPathEntry.getWarFilter();
List earFilter = classPathEntry.getEarFilter();
List jmodFilter = classPathEntry.getJmodFilter();
List zipFilter = classPathEntry.getZipFilter();
System.out.println("Preparing output " +
(isApk ? "apk" :
isJar ? "jar" :
isAar ? "aar" :
isWar ? "war" :
isEar ? "ear" :
isJmod ? "jmod" :
isZip ? "zip" :
"directory") +
" [" + classPathEntry.getName() + "]" +
(filter != null ||
apkFilter != null ||
jarFilter != null ||
aarFilter != null ||
warFilter != null ||
earFilter != null ||
jmodFilter != null ||
zipFilter != null ? " (filtered)" : ""));
DataEntryWriter writer = new DirectoryWriter(classPathEntry.getFile(),
isApk ||
isJar ||
isAar ||
isWar ||
isEar ||
isJmod ||
isZip);
// If the output is an archive, we'll flatten (unpack the contents of)
// higher level input archives, e.g. when writing into a jar file, we
// flatten zip files.
boolean flattenApks = false;
boolean flattenJars = flattenApks || isApk;
boolean flattenAars = flattenJars || isJar;
boolean flattenWars = flattenAars || isAar;
boolean flattenEars = flattenWars || isWar;
boolean flattenJmods = flattenEars || isEar;
boolean flattenZips = flattenJmods || isJmod;
// Set up the filtered jar writers.
writer = wrapInJarWriter(writer, flattenZips, isZip, ".zip", zipFilter, null, null);
writer = wrapInJarWriter(writer, flattenJmods, isJmod, ".jmod", jmodFilter, ClassConstants.JMOD_HEADER, ClassConstants.JMOD_CLASS_FILE_PREFIX);
writer = wrapInJarWriter(writer, flattenEars, isEar, ".ear", earFilter, null, null);
writer = wrapInJarWriter(writer, flattenWars, isWar, ".war", warFilter, null, ClassConstants.WAR_CLASS_FILE_PREFIX);
writer = wrapInJarWriter(writer, flattenAars, isAar, ".aar", aarFilter, null, null);
writer = wrapInJarWriter(writer, flattenJars, isJar, ".jar", jarFilter, null, null);
writer = wrapInJarWriter(writer, flattenApks, isApk, ".apk", apkFilter, null, null);
// Set up for writing out the program classes.
writer = new ClassDataEntryWriter(programClassPool, writer);
// Add a data entry filter, if specified.
writer = filter != null ?
new FilteredDataEntryWriter(
new DataEntryNameFilter(
new ListParser(new FileNameParser()).parse(filter)),
writer) :
writer;
// Add a writer for the injected classes.
writer = new ExtraDataEntryWriter(extraClassNameMap,
writer,
writer,
ClassConstants.CLASS_FILE_EXTENSION);
// Let the writer cascade, if specified.
return alternativeWriter != null ?
new CascadingDataEntryWriter(writer, alternativeWriter) :
writer;
}
/**
* Wraps the given DataEntryWriter in a JarWriter, filtering if necessary.
*/
private DataEntryWriter wrapInJarWriter(DataEntryWriter writer,
boolean flatten,
boolean isOutputJar,
String jarFilterExtension,
List jarFilter,
byte[] jarHeader,
String classFilePrefix)
{
// Flatten jars or zip them up.
DataEntryWriter jarWriter;
if (flatten)
{
// Unpack the jar.
jarWriter = new ParentDataEntryWriter(writer);
}
else
{
// Pack the jar.
jarWriter = new JarWriter(jarHeader, writer);
// Add a prefix for class files inside the jar, if specified.
if (classFilePrefix != null)
{
jarWriter =
new FilteredDataEntryWriter(
new DataEntryNameFilter(
new ExtensionMatcher(ClassConstants.CLASS_FILE_EXTENSION)),
new PrefixAddingDataEntryWriter(classFilePrefix,
jarWriter),
jarWriter);
}
}
// Either zip up the jar or delegate to the original writer.
return
new FilteredDataEntryWriter(
new DataEntryParentFilter(
new DataEntryNameFilter(
new ExtensionMatcher(jarFilterExtension))),
// The parent of the data entry is a jar.
// Write the data entry to the jar.
// Apply the jar filter, if specified, to the parent.
jarFilter != null ?
new FilteredDataEntryWriter(
new DataEntryParentFilter(
new DataEntryNameFilter(
new ListParser(new FileNameParser()).parse(jarFilter))),
jarWriter) :
jarWriter,
// The parent of the data entry is not a jar.
// Write the entry to a jar anyway if the output is a jar.
// Otherwise just delegate to the original writer.
isOutputJar ?
jarWriter :
writer);
}
}
