Files
ElderlyDialer/tools/screenmatch/ScreenMatch.java
T

175 lines
9.1 KiB
Java

import java.io.InputStream;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Arrays;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.TreeSet;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Stream;
import javax.xml.XMLConstants;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import java.io.StringWriter;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
/** Build-time only, runs on JDK 11+; never packaged into the Android app. */
public final class ScreenMatch {
private static final Pattern VALUE = Pattern.compile("([+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+))(dp|dip|sp)");
public static void main(String[] args) throws Exception {
if (args.length < 2 || args.length > 3) {
throw new IllegalArgumentException("Usage: java ScreenMatch.java <projectRoot> <config> [previewResDir]");
}
Path root = Paths.get(args[0]).toAbsolutePath().normalize();
Properties config = new Properties();
try (java.io.Reader reader = Files.newBufferedReader(Paths.get(args[1]), StandardCharsets.UTF_8)) {
config.load(reader);
}
Path res = root.resolve(config.getProperty("res_dir", "app/src/main/res")).normalize();
Path output = args.length == 3 ? Paths.get(args[2]).toAbsolutePath().normalize() : res;
Path source = res.resolve("values/dimens.xml");
BigDecimal base = new BigDecimal(config.getProperty("base_dp", "360"));
int min = integer(config, "min_dp", 240);
int max = integer(config, "max_dp", 600);
int step = integer(config, "step_dp", 2);
String qualifier = config.getProperty("qualifier", "sw").trim();
if (base.signum() <= 0 || min <= 0 || max < min || max > 10000 || step <= 0
|| !(qualifier.equals("sw") || qualifier.equals("w"))) {
throw new IllegalArgumentException("Invalid base/range/step/qualifier (maximum width: 10000dp)");
}
boolean scaleSp = bool(config, "scale_sp", true);
Set<String> excluded = new HashSet<>(Arrays.asList(config.getProperty("exclude_names", "").split(",")));
Set<String> trimmedExcluded = new HashSet<>();
for (String name : excluded) trimmedExcluded.add(name.trim());
TreeSet<Integer> widths = new TreeSet<>();
for (int width = min; width <= max; width += step) widths.add(width);
widths.add(max);
for (String value : config.getProperty("extra_dp", "").split(",")) {
if (!value.trim().isEmpty()) widths.add(Integer.parseInt(value.trim()));
}
Pattern folderPattern = Pattern.compile("values-" + qualifier + "(\\d+)dp");
if (bool(config, "include_existing", true)) {
try (Stream<Path> paths = Files.list(res)) {
paths.filter(Files::isDirectory).forEach(path -> {
Matcher match = folderPattern.matcher(path.getFileName().toString());
if (match.matches() && Files.exists(path.resolve("dimens.xml"))) {
widths.add(Integer.parseInt(match.group(1)));
}
});
}
}
for (int width : widths) {
if (width <= 0 || width > 10000) throw new IllegalArgumentException("Invalid width: " + width);
}
// Fail before writing if another qualifier family could shadow generated values.
String other = qualifier.equals("sw") ? "w" : "sw";
try (Stream<Path> paths = Files.list(res)) {
if (paths.anyMatch(path -> path.getFileName().toString().matches("values-" + other + "\\d+dp")
&& Files.exists(path.resolve("dimens.xml")))) {
throw new IllegalStateException("Migrate existing values-" + other + "NNNdp/dimens.xml before switching qualifier families");
}
}
Document original = read(source);
Set<String> sourceNames = names(original);
if (sourceNames.isEmpty()) throw new IllegalArgumentException("No dimensions found in " + source);
// Render and validate all files first, so an invalid resource cannot cause partial generation.
Map<Path, String> generated = new LinkedHashMap<>();
for (int width : widths) {
Path target = output.resolve("values-" + qualifier + width + "dp/dimens.xml");
if (Files.exists(target) && !sourceNames.containsAll(names(read(target)))) {
throw new IllegalStateException("Target contains custom dimensions absent from base; merge them first: " + target);
}
Document doc = (Document) original.cloneNode(true);
NodeList dimensions = doc.getDocumentElement().getElementsByTagName("dimen");
for (int i = 0; i < dimensions.getLength(); i++) {
Element dimension = (Element) dimensions.item(i);
Matcher match = VALUE.matcher(dimension.getTextContent().trim());
if (!trimmedExcluded.contains(dimension.getAttribute("name")) && match.matches()
&& (scaleSp || !match.group(2).equals("sp"))) {
BigDecimal value = new BigDecimal(match.group(1)).multiply(BigDecimal.valueOf(width))
.divide(base, 4, RoundingMode.HALF_UP).stripTrailingZeros();
dimension.setTextContent(value.toPlainString() + match.group(2));
}
}
doc.insertBefore(doc.createComment(" Generated by tools/screenmatch/ScreenMatch.java; edit values/dimens.xml instead. "),
doc.getDocumentElement());
TransformerFactory factory = TransformerFactory.newInstance();
factory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true);
Transformer transformer = factory.newTransformer();
transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
StringWriter writer = new StringWriter();
transformer.transform(new DOMSource(doc), new StreamResult(writer));
generated.put(target, writer.toString().replace("\r\n", "\n"));
}
int changed = 0;
for (Map.Entry<Path, String> entry : generated.entrySet()) {
Path target = entry.getKey();
byte[] bytes = entry.getValue().getBytes(StandardCharsets.UTF_8);
if (!Files.exists(target) || !Arrays.equals(Files.readAllBytes(target), bytes)) {
Files.createDirectories(target.getParent());
Files.write(target, bytes);
changed++;
}
}
System.out.println("ScreenMatch: " + sourceNames.size() + " dimensions, " + widths.size()
+ " widths, " + changed + " files updated -> " + output);
System.out.println("No density changes. Existing widths are retained; obsolete files are not deleted.");
}
private static int integer(Properties config, String key, int fallback) {
return Integer.parseInt(config.getProperty(key, Integer.toString(fallback)).trim());
}
private static boolean bool(Properties config, String key, boolean fallback) {
String value = config.getProperty(key, Boolean.toString(fallback)).trim();
if (!value.equals("true") && !value.equals("false")) throw new IllegalArgumentException("Invalid boolean: " + key);
return Boolean.parseBoolean(value);
}
private static Document read(Path path) throws Exception {
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
factory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true);
factory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
factory.setXIncludeAware(false);
factory.setExpandEntityReferences(false);
try (InputStream input = Files.newInputStream(path)) {
return factory.newDocumentBuilder().parse(input);
}
}
private static Set<String> names(Document doc) {
if (!doc.getDocumentElement().getTagName().equals("resources")) {
throw new IllegalArgumentException("Expected resources root");
}
Set<String> names = new HashSet<>();
NodeList children = doc.getDocumentElement().getChildNodes();
for (int i = 0; i < children.getLength(); i++) {
Node child = children.item(i);
if (child instanceof Element) {
Element element = (Element) child;
if (!element.getTagName().equals("dimen") || element.getAttribute("name").isEmpty()
|| !names.add(element.getAttribute("name"))) {
throw new IllegalArgumentException("Only uniquely named dimen resources are supported");
}
}
}
return names;
}
}