src/tools/android/java/com/google/devtools/build/android/DensitySpecificResourceFilter.java - bazel - Git at Google

 // Copyright 2015 The Bazel Authors. All rights reserved.
 //
 // 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.google.devtools.build.android;

 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Function;
 import com.google.common.base.Joiner;
 import com.google.common.base.MoreObjects;
 import com.google.common.base.Predicate;
 import com.google.common.collect.ArrayListMultimap;
 import com.google.common.collect.Collections2;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableMultimap;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Multimap;
 import com.google.common.collect.Ordering;
 import com.google.devtools.build.android.AndroidResourceMerger.MergingException;
 import java.io.IOException;
 import java.nio.file.FileVisitOption;
 import java.nio.file.FileVisitResult;
 import java.nio.file.Files;
 import java.nio.file.LinkOption;
 import java.nio.file.Path;
 import java.nio.file.SimpleFileVisitor;
 import java.nio.file.attribute.BasicFileAttributes;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.EnumSet;
 import java.util.List;
 import javax.annotation.Nullable;

 /** Filters a {@link MergedAndroidData} resource drawables to the specified densities. */
 public class DensitySpecificResourceFilter {
   private static class ResourceInfo {
     /** Path to an actual file resource, instead of a directory. */
     private Path resource;

     private String restype;
     private String qualifiers;
     private String density;
     private String resid;

     public ResourceInfo(
         Path resource, String restype, String qualifiers, String density, String resid) {
       this.resource = resource;
       this.restype = restype;
       this.qualifiers = qualifiers;
       this.density = density;
       this.resid = resid;
     }

     public Path getResource() {
       return this.resource;
     }

     public String getRestype() {
       return this.restype;
     }

     public String getQualifiers() {
       return this.qualifiers;
     }

     public String getDensity() {
       return this.density;
     }

     public String getResid() {
       return this.resid;
     }

     @Override
     public String toString() {
       return MoreObjects.toStringHelper(this)
           .add("resource", resource)
           .add("restype", restype)
           .add("qualifiers", qualifiers)
           .add("density", density)
           .add("resid", resid)
           .toString();
     }
   }

   private static class RecursiveFileCopier extends SimpleFileVisitor<Path> {
     private final Path copyToPath;
     private final List<Path> copiedSourceFiles = new ArrayList<>();
     private Path root;

     public RecursiveFileCopier(final Path copyToPath, final Path root) {
       this.copyToPath = copyToPath;
       this.root = root;
     }

     @Override
     public FileVisitResult visitFile(Path path, BasicFileAttributes attrs) throws IOException {
       Path copyTo = copyToPath.resolve(root.relativize(path));
       Files.createDirectories(copyTo.getParent());
       Files.copy(path, copyTo, LinkOption.NOFOLLOW_LINKS);
       copiedSourceFiles.add(copyTo);
       return FileVisitResult.CONTINUE;
     }

     public List<Path> getCopiedFiles() {
       return copiedSourceFiles;
     }
   }

   private final List<String> densities;
   private final Path out;
   private final Path working;

   private static final ImmutableMap<String, Integer> DENSITY_MAP =
       new ImmutableMap.Builder<String, Integer>()
           .put("nodpi", 0)
           .put("ldpi", 120)
           .put("mdpi", 160)
           .put("tvdpi", 213)
           .put("hdpi", 240)
           .put("280dpi", 280)
           .put("xhdpi", 320)
           .put("340dpi", 340)
           .put("400dpi", 400)
           .put("420dpi", 420)
           .put("xxhdpi", 480)
           .put("560dpi", 560)
           .put("xxxhdpi", 640)
           .build();

   private static final Function<ResourceInfo, String> GET_RESOURCE_ID =
       new Function<ResourceInfo, String>() {
         @Override
         public String apply(ResourceInfo info) {
           return info.getResid();
         }
       };

   private static final Function<ResourceInfo, String> GET_RESOURCE_QUALIFIERS =
       new Function<ResourceInfo, String>() {
         @Override
         public String apply(ResourceInfo info) {
           return info.getQualifiers();
         }
       };

   private static final Function<ResourceInfo, Path> GET_RESOURCE_PATH =
       new Function<ResourceInfo, Path>() {
         @Override
         public Path apply(ResourceInfo info) {
           return info.getResource();
         }
       };

   /**
    * @param densities An array of string densities to use for filtering resources
    * @param out The path to use for name spacing the final resource directory.
    * @param working The path of the working directory for the filtering
    */
   public DensitySpecificResourceFilter(List<String> densities, Path out, Path working)
       throws MergingException {
     this.densities = densities;
     this.out = out;
     this.working = working;

     for (String density : densities) {
       if (!DENSITY_MAP.containsKey(density)) {
         throw MergingException.withMessage(density + " is not a known density qualifier.");
       }
     }
   }

   @VisibleForTesting
   List<Path> getResourceToRemove(List<Path> resourcePaths) {
     Predicate<ResourceInfo> requestedDensityFilter =
         new Predicate<ResourceInfo>() {
           @Override
           public boolean apply(@Nullable ResourceInfo info) {
             return !densities.contains(info.getDensity());
           }
         };

     List<ResourceInfo> resourceInfos = getResourceInfos(resourcePaths);
     List<ResourceInfo> densityResourceInfos = filterDensityResourceInfos(resourceInfos);
     List<ResourceInfo> resourceInfoToRemove = new ArrayList<>();

     Multimap<String, ResourceInfo> fileGroups =
         groupResourceInfos(densityResourceInfos, GET_RESOURCE_ID);

     for (String key : fileGroups.keySet()) {
       Multimap<String, ResourceInfo> qualifierGroups =
           groupResourceInfos(fileGroups.get(key), GET_RESOURCE_QUALIFIERS);

       for (String qualifiers : qualifierGroups.keySet()) {
         Collection<ResourceInfo> qualifierResourceInfos = qualifierGroups.get(qualifiers);

         if (qualifierResourceInfos.size() != 1) {
           List<ResourceInfo> sortedResourceInfos =
               Ordering.natural()
                   .onResultOf(
                       new Function<ResourceInfo, Double>() {
                         @Override
                         public Double apply(ResourceInfo info) {
                           return matchScore(info, densities);
                         }
                       })
                   .immutableSortedCopy(qualifierResourceInfos);
           resourceInfoToRemove.addAll(
               Collections2.filter(
                   sortedResourceInfos.subList(1, sortedResourceInfos.size()),
                   requestedDensityFilter));
         }
       }
     }

     return ImmutableList.copyOf(Lists.transform(resourceInfoToRemove, GET_RESOURCE_PATH));
   }

   private static void removeResources(List<Path> resourceInfoToRemove) {
     for (Path resource : resourceInfoToRemove) {
       resource.toFile().delete();
     }
   }

   private static Multimap<String, ResourceInfo> groupResourceInfos(
       final Collection<ResourceInfo> resourceInfos, Function<ResourceInfo, String> keyFunction) {
     Multimap<String, ResourceInfo> resourceGroups = ArrayListMultimap.create();

     for (ResourceInfo resourceInfo : resourceInfos) {
       resourceGroups.put(keyFunction.apply(resourceInfo), resourceInfo);
     }

     return ImmutableMultimap.copyOf(resourceGroups);
   }

   private static List<ResourceInfo> getResourceInfos(final List<Path> resourcePaths) {
     List<ResourceInfo> resourceInfos = new ArrayList<>();

     for (Path resourcePath : resourcePaths) {
       String qualifiers = resourcePath.getParent().getFileName().toString();
       String density = "";

       for (String densityName : DENSITY_MAP.keySet()) {
         if (qualifiers.contains("-" + densityName)) {
           qualifiers = qualifiers.replace("-" + densityName, "");
           density = densityName;
         }
       }

       String[] qualifierArray = qualifiers.split("-");
       String restype = qualifierArray[0];
       qualifiers =
           (qualifierArray.length) > 0
               ? Joiner.on("-").join(Arrays.copyOfRange(qualifierArray, 1, qualifierArray.length))
               : "";
       resourceInfos.add(
           new ResourceInfo(
               resourcePath, restype, qualifiers, density, resourcePath.getFileName().toString()));
     }

     return ImmutableList.copyOf(resourceInfos);
   }

   private static List<ResourceInfo> filterDensityResourceInfos(
       final List<ResourceInfo> resourceInfos) {
     List<ResourceInfo> densityResourceInfos = new ArrayList<>();

     for (ResourceInfo info : resourceInfos) {
       if (info.getRestype().equals("drawable")
           && !info.getDensity().equals("")
           && !info.getDensity().equals("nodpi")
           && !info.getResid().endsWith(".xml")) {
         densityResourceInfos.add(info);
       }
     }

     return ImmutableList.copyOf(densityResourceInfos);
   }

   private static double matchScore(ResourceInfo resource, List<String> densities) {
     double score = 0;
     for (String density : densities) {
       score += computeAffinity(DENSITY_MAP.get(resource.getDensity()), DENSITY_MAP.get(density));
     }
     return score;
   }

   private static double computeAffinity(int resourceDensity, int density) {
     if (resourceDensity == density) {
       // Exact match is the best.
       return -2;
     } else if (resourceDensity == 2 * density) {
       // It's very efficient to downsample an image that's exactly 2x the screen
       // density, so we prefer that over other non-perfect matches.
       return -1;
     } else {
       double affinity = Math.log((double) density / resourceDensity) / Math.log(2);

       // We give a slight bump to images that have the same multiplier but are higher quality.
       if (affinity < 0) {
         affinity = Math.abs(affinity) - 0.01;
       }
       return affinity;
     }
   }

   /** Filters the contents of a resource directory. */
   public Path filter(Path unFilteredResourceDir) {
     // no densities to filter, so skip.
     if (densities.isEmpty()) {
       return unFilteredResourceDir;
     }
     final Path filteredResourceDir = out.resolve(working.relativize(unFilteredResourceDir));
     RecursiveFileCopier fileVisitor =
         new RecursiveFileCopier(filteredResourceDir, unFilteredResourceDir);
     try {
       Files.walkFileTree(
           unFilteredResourceDir,
           EnumSet.of(FileVisitOption.FOLLOW_LINKS),
           Integer.MAX_VALUE,
           fileVisitor);
     } catch (IOException e) {
       throw new RuntimeException(e);
     }
     removeResources(getResourceToRemove(fileVisitor.getCopiedFiles()));
     return filteredResourceDir;
   }
 }
	// Copyright 2015 The Bazel Authors. All rights reserved.
	//
	// 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.google.devtools.build.android;

	import com.google.common.annotations.VisibleForTesting;
	import com.google.common.base.Function;
	import com.google.common.base.Joiner;
	import com.google.common.base.MoreObjects;
	import com.google.common.base.Predicate;
	import com.google.common.collect.ArrayListMultimap;
	import com.google.common.collect.Collections2;
	import com.google.common.collect.ImmutableList;
	import com.google.common.collect.ImmutableMap;
	import com.google.common.collect.ImmutableMultimap;
	import com.google.common.collect.Lists;
	import com.google.common.collect.Multimap;
	import com.google.common.collect.Ordering;
	import com.google.devtools.build.android.AndroidResourceMerger.MergingException;
	import java.io.IOException;
	import java.nio.file.FileVisitOption;
	import java.nio.file.FileVisitResult;
	import java.nio.file.Files;
	import java.nio.file.LinkOption;
	import java.nio.file.Path;
	import java.nio.file.SimpleFileVisitor;
	import java.nio.file.attribute.BasicFileAttributes;
	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.Collection;
	import java.util.EnumSet;
	import java.util.List;
	import javax.annotation.Nullable;

	/** Filters a {@link MergedAndroidData} resource drawables to the specified densities. */
	public class DensitySpecificResourceFilter {
	private static class ResourceInfo {
	/** Path to an actual file resource, instead of a directory. */
	private Path resource;

	private String restype;
	private String qualifiers;
	private String density;
	private String resid;

	public ResourceInfo(
	Path resource, String restype, String qualifiers, String density, String resid) {
	this.resource = resource;
	this.restype = restype;
	this.qualifiers = qualifiers;
	this.density = density;
	this.resid = resid;
	}

	public Path getResource() {
	return this.resource;
	}

	public String getRestype() {
	return this.restype;
	}

	public String getQualifiers() {
	return this.qualifiers;
	}

	public String getDensity() {
	return this.density;
	}

	public String getResid() {
	return this.resid;
	}

	@Override
	public String toString() {
	return MoreObjects.toStringHelper(this)
	.add("resource", resource)
	.add("restype", restype)
	.add("qualifiers", qualifiers)
	.add("density", density)
	.add("resid", resid)
	.toString();
	}
	}

	private static class RecursiveFileCopier extends SimpleFileVisitor<Path> {
	private final Path copyToPath;
	private final List<Path> copiedSourceFiles = new ArrayList<>();
	private Path root;

	public RecursiveFileCopier(final Path copyToPath, final Path root) {
	this.copyToPath = copyToPath;
	this.root = root;
	}

	@Override
	public FileVisitResult visitFile(Path path, BasicFileAttributes attrs) throws IOException {
	Path copyTo = copyToPath.resolve(root.relativize(path));
	Files.createDirectories(copyTo.getParent());
	Files.copy(path, copyTo, LinkOption.NOFOLLOW_LINKS);
	copiedSourceFiles.add(copyTo);
	return FileVisitResult.CONTINUE;
	}

	public List<Path> getCopiedFiles() {
	return copiedSourceFiles;
	}
	}

	private final List<String> densities;
	private final Path out;
	private final Path working;

	private static final ImmutableMap<String, Integer> DENSITY_MAP =
	new ImmutableMap.Builder<String, Integer>()
	.put("nodpi", 0)
	.put("ldpi", 120)
	.put("mdpi", 160)
	.put("tvdpi", 213)
	.put("hdpi", 240)
	.put("280dpi", 280)
	.put("xhdpi", 320)
	.put("340dpi", 340)
	.put("400dpi", 400)
	.put("420dpi", 420)
	.put("xxhdpi", 480)
	.put("560dpi", 560)
	.put("xxxhdpi", 640)
	.build();

	private static final Function<ResourceInfo, String> GET_RESOURCE_ID =
	new Function<ResourceInfo, String>() {
	@Override
	public String apply(ResourceInfo info) {
	return info.getResid();
	}
	};

	private static final Function<ResourceInfo, String> GET_RESOURCE_QUALIFIERS =
	new Function<ResourceInfo, String>() {
	@Override
	public String apply(ResourceInfo info) {
	return info.getQualifiers();
	}
	};

	private static final Function<ResourceInfo, Path> GET_RESOURCE_PATH =
	new Function<ResourceInfo, Path>() {
	@Override
	public Path apply(ResourceInfo info) {
	return info.getResource();
	}
	};

	/**
	* @param densities An array of string densities to use for filtering resources
	* @param out The path to use for name spacing the final resource directory.
	* @param working The path of the working directory for the filtering
	*/
	public DensitySpecificResourceFilter(List<String> densities, Path out, Path working)
	throws MergingException {
	this.densities = densities;
	this.out = out;
	this.working = working;

	for (String density : densities) {
	if (!DENSITY_MAP.containsKey(density)) {
	throw MergingException.withMessage(density + " is not a known density qualifier.");
	}
	}
	}

	@VisibleForTesting
	List<Path> getResourceToRemove(List<Path> resourcePaths) {
	Predicate<ResourceInfo> requestedDensityFilter =
	new Predicate<ResourceInfo>() {
	@Override
	public boolean apply(@Nullable ResourceInfo info) {
	return !densities.contains(info.getDensity());
	}
	};

	List<ResourceInfo> resourceInfos = getResourceInfos(resourcePaths);
	List<ResourceInfo> densityResourceInfos = filterDensityResourceInfos(resourceInfos);
	List<ResourceInfo> resourceInfoToRemove = new ArrayList<>();

	Multimap<String, ResourceInfo> fileGroups =
	groupResourceInfos(densityResourceInfos, GET_RESOURCE_ID);

	for (String key : fileGroups.keySet()) {
	Multimap<String, ResourceInfo> qualifierGroups =
	groupResourceInfos(fileGroups.get(key), GET_RESOURCE_QUALIFIERS);

	for (String qualifiers : qualifierGroups.keySet()) {
	Collection<ResourceInfo> qualifierResourceInfos = qualifierGroups.get(qualifiers);

	if (qualifierResourceInfos.size() != 1) {
	List<ResourceInfo> sortedResourceInfos =
	Ordering.natural()
	.onResultOf(
	new Function<ResourceInfo, Double>() {
	@Override
	public Double apply(ResourceInfo info) {
	return matchScore(info, densities);
	}
	})
	.immutableSortedCopy(qualifierResourceInfos);
	resourceInfoToRemove.addAll(
	Collections2.filter(
	sortedResourceInfos.subList(1, sortedResourceInfos.size()),
	requestedDensityFilter));
	}
	}
	}

	return ImmutableList.copyOf(Lists.transform(resourceInfoToRemove, GET_RESOURCE_PATH));
	}

	private static void removeResources(List<Path> resourceInfoToRemove) {
	for (Path resource : resourceInfoToRemove) {
	resource.toFile().delete();
	}
	}

	private static Multimap<String, ResourceInfo> groupResourceInfos(
	final Collection<ResourceInfo> resourceInfos, Function<ResourceInfo, String> keyFunction) {
	Multimap<String, ResourceInfo> resourceGroups = ArrayListMultimap.create();

	for (ResourceInfo resourceInfo : resourceInfos) {
	resourceGroups.put(keyFunction.apply(resourceInfo), resourceInfo);
	}

	return ImmutableMultimap.copyOf(resourceGroups);
	}

	private static List<ResourceInfo> getResourceInfos(final List<Path> resourcePaths) {
	List<ResourceInfo> resourceInfos = new ArrayList<>();

	for (Path resourcePath : resourcePaths) {
	String qualifiers = resourcePath.getParent().getFileName().toString();
	String density = "";

	for (String densityName : DENSITY_MAP.keySet()) {
	if (qualifiers.contains("-" + densityName)) {
	qualifiers = qualifiers.replace("-" + densityName, "");
	density = densityName;
	}
	}

	String[] qualifierArray = qualifiers.split("-");
	String restype = qualifierArray[0];
	qualifiers =
	(qualifierArray.length) > 0
	? Joiner.on("-").join(Arrays.copyOfRange(qualifierArray, 1, qualifierArray.length))
	: "";
	resourceInfos.add(
	new ResourceInfo(
	resourcePath, restype, qualifiers, density, resourcePath.getFileName().toString()));
	}

	return ImmutableList.copyOf(resourceInfos);
	}

	private static List<ResourceInfo> filterDensityResourceInfos(
	final List<ResourceInfo> resourceInfos) {
	List<ResourceInfo> densityResourceInfos = new ArrayList<>();

	for (ResourceInfo info : resourceInfos) {
	if (info.getRestype().equals("drawable")
	&& !info.getDensity().equals("")
	&& !info.getDensity().equals("nodpi")
	&& !info.getResid().endsWith(".xml")) {
	densityResourceInfos.add(info);
	}
	}

	return ImmutableList.copyOf(densityResourceInfos);
	}

	private static double matchScore(ResourceInfo resource, List<String> densities) {
	double score = 0;
	for (String density : densities) {
	score += computeAffinity(DENSITY_MAP.get(resource.getDensity()), DENSITY_MAP.get(density));
	}
	return score;
	}

	private static double computeAffinity(int resourceDensity, int density) {
	if (resourceDensity == density) {
	// Exact match is the best.
	return -2;
	} else if (resourceDensity == 2 * density) {
	// It's very efficient to downsample an image that's exactly 2x the screen
	// density, so we prefer that over other non-perfect matches.
	return -1;
	} else {
	double affinity = Math.log((double) density / resourceDensity) / Math.log(2);

	// We give a slight bump to images that have the same multiplier but are higher quality.
	if (affinity < 0) {
	affinity = Math.abs(affinity) - 0.01;
	}
	return affinity;
	}
	}

	/** Filters the contents of a resource directory. */
	public Path filter(Path unFilteredResourceDir) {
	// no densities to filter, so skip.
	if (densities.isEmpty()) {
	return unFilteredResourceDir;
	}
	final Path filteredResourceDir = out.resolve(working.relativize(unFilteredResourceDir));
	RecursiveFileCopier fileVisitor =
	new RecursiveFileCopier(filteredResourceDir, unFilteredResourceDir);
	try {
	Files.walkFileTree(
	unFilteredResourceDir,
	EnumSet.of(FileVisitOption.FOLLOW_LINKS),
	Integer.MAX_VALUE,
	fileVisitor);
	} catch (IOException e) {
	throw new RuntimeException(e);
	}
	removeResources(getResourceToRemove(fileVisitor.getCopiedFiles()));
	return filteredResourceDir;
	}
	}