src/com/facebook/buck/util/Filters.java - buck - Git at Google

 /*
  * Copyright 2012-present Facebook, Inc.
  *
  * 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.facebook.buck.util;

 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Function;
 import com.google.common.base.Predicate;
 import com.google.common.collect.HashBasedTable;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Ordering;
 import com.google.common.collect.Sets;
 import com.google.common.collect.Table;

 import java.nio.file.Path;
 import java.util.Collection;
 import java.util.Map;
 import java.util.Set;

 public class Filters {

   /** Utility class: do not instantiate. */
   private Filters() {}

   public enum Density {
     LDPI("ldpi", 120.0),
     NO_QUALIFIER("", 160.0),
     MDPI("mdpi", 160.0),
     TVDPI("tvdpi", 213.0),
     HDPI("hdpi", 240.0),
     XHDPI("xhdpi", 320.0),
     XXHDPI("xxhdpi", 480.0),
     XXXHDPI("xxxhdpi", 640.0);

     private final String qualifier;
     private final double value;

     public static final Ordering<Density> ORDERING = Ordering.natural();

     Density(String qualifier, double value) {
       this.qualifier = qualifier;
       this.value = value;
     }

     public double value() {
       return value;
     }

     @Override
     public String toString() {
       return qualifier;
     }

     public static Density from(String s) {
       return s.isEmpty() ? NO_QUALIFIER : valueOf(s.toUpperCase());
     }

     public static boolean isDensity(String s) {
       for (Density choice : values()) {
         if (choice.toString().equals(s)) {
           return true;
         }
       }
       return false;
     }
   }

   public static class Qualifiers {
     /** e.g. "xhdpi" */
     public final Filters.Density density;
     /** e.g. "de-v11" */
     public final String others;

     /**
      * Splits off the density qualifier from a drawable.
      * @param path path to a drawable
      */
     public Qualifiers(Path path) {
       Filters.Density density = Density.NO_QUALIFIER;
       StringBuilder othersBuilder = new StringBuilder();
       for (String qualifier : path.getParent().getFileName().toString().split("-")) {
         if (qualifier.equals("drawable")) { // We're assuming they're all drawables.
           continue;
         }

         if (Filters.Density.isDensity(qualifier)) {
           density = Density.from(qualifier);
         } else {
           othersBuilder.append((MoreStrings.isEmpty(othersBuilder) ? "" : "-") + qualifier);
         }

       }
       this.density = density;
       this.others = othersBuilder.toString();
     }
   }

   /**
    * Takes a list of image files (as paths), and a target density (mdpi, hdpi, xhdpi), and
    * returns a list of files which can be safely left out when building an APK for phones with that
    * screen density. That APK will run on other screens as well but look worse due to scaling.
    * <p>
    * Each combination of non-density qualifiers is processed separately. For example, if we have
    * {@code drawable-hdpi, drawable-mdpi, drawable-xhdpi, drawable-hdpi-ro}, for a target of {@code
    * mdpi}, we'll be keeping {@code drawable-mdpi, drawable-hdpi-ro}.
    * @param candidates list of paths to image files
    * @param targetDensities densities we want to keep
    * @param canDownscale do we have access to an image scaler
    * @return set of files to remove
    */
   @VisibleForTesting
   static Set<Path> filterByDensity(
       Collection<Path> candidates,
       Set<Filters.Density> targetDensities,
       boolean canDownscale) {
     ImmutableSet.Builder<Path> removals = ImmutableSet.builder();

     Table<String, Density, Path> imageValues = HashBasedTable.create();

     // Create mappings for drawables. If candidate == "<base>/drawable-<dpi>-<other>/<filename>",
     // then we'll record a mapping of the form ("<base>/<filename>/<other>", "<dpi>") -> candidate.
     // For example:
     //                                    mdpi                               hdpi
     //                       --------------------------------------------------------------------
     // key: res/some.png/    |  res/drawable-mdpi/some.png          res/drawable-hdpi/some.png
     // key: res/some.png/fr  |  res/drawable-fr-hdpi/some.png
     for (Path candidate : candidates) {
       Qualifiers qualifiers = new Qualifiers(candidate);

       String filename = candidate.getFileName().toString();
       Density density = qualifiers.density;
       String resDirectory = candidate.getParent().getParent().toString();
       String key = String.format("%s/%s/%s", resDirectory, filename, qualifiers.others);
       imageValues.put(key, density, candidate);
     }

     for (String key : imageValues.rowKeySet()) {
       Map<Density, Path> options = imageValues.row(key);
       Set<Density> available = options.keySet();

       // This is to make sure we preserve the existing structure of drawable/ files.
       Set<Density> targets = targetDensities;
       if (available.contains(Density.NO_QUALIFIER) && !available.contains(Density.MDPI)) {
         targets = Sets.newHashSet(Iterables.transform(targetDensities,
             new Function<Density, Density>() {
               @Override
               public Density apply(Density input) {
                 return (input == Density.MDPI) ? Density.NO_QUALIFIER : input;
               }
             }));
       }

       // We intend to keep all available targeted densities.
       Set<Density> toKeep = Sets.newHashSet(Sets.intersection(available, targets));

       // Make sure we have a decent fit for the largest target density.
       Density largestTarget = Density.ORDERING.max(targets);
       if (!available.contains(largestTarget)) {
         Density fallback = null;
         // Downscaling nine-patch drawables would require extra logic, not doing that yet.
         if (canDownscale && !options.values().iterator().next().toString().endsWith(".9.png")) {
           // Highest possible quality, because we'll downscale it.
           fallback = Density.ORDERING.max(available);
         } else {
           // We want to minimize size, so we'll go for the smallest available density that's
           // still larger than the missing one and, missing that, for the largest available.
           for (Density candidate : Density.ORDERING.reverse().sortedCopy(available)) {
             if (fallback == null || Density.ORDERING.compare(candidate, largestTarget) > 0) {
               fallback = candidate;
             }
           }
         }
         toKeep.add(fallback);
       }

       // Mark remaining densities for removal.
       for (Density density : Sets.difference(available, toKeep)) {
         removals.add(options.get(density));
       }
     }

     return removals.build();
   }

   /**
    * Given a list of paths of available drawables, and a target screen density, returns a
    * {@link com.google.common.base.Predicate} that fails for drawables of a different
    * density, whenever they can be safely removed.
    * @param candidates list of available drawables
    * @param targetDensities set of e.g. {@code "mdpi"}, {@code "ldpi"} etc.
    * @param canDownscale if no exact match is available, retain the highest quality
    * @return a predicate as above
    */
   public static Predicate<Path> createImageDensityFilter(
       Collection<Path> candidates,
       Set<Filters.Density> targetDensities,
       boolean canDownscale) {
     final Set<Path> pathsToRemove = filterByDensity(candidates, targetDensities, canDownscale);
     return new Predicate<Path>() {
       @Override
       public boolean apply(Path path) {
         return !pathsToRemove.contains(path);
       }
     };
   }
 }
	/*
	* Copyright 2012-present Facebook, Inc.
	*
	* 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.facebook.buck.util;

	import com.google.common.annotations.VisibleForTesting;
	import com.google.common.base.Function;
	import com.google.common.base.Predicate;
	import com.google.common.collect.HashBasedTable;
	import com.google.common.collect.ImmutableSet;
	import com.google.common.collect.Iterables;
	import com.google.common.collect.Ordering;
	import com.google.common.collect.Sets;
	import com.google.common.collect.Table;

	import java.nio.file.Path;
	import java.util.Collection;
	import java.util.Map;
	import java.util.Set;

	public class Filters {

	/** Utility class: do not instantiate. */
	private Filters() {}

	public enum Density {
	LDPI("ldpi", 120.0),
	NO_QUALIFIER("", 160.0),
	MDPI("mdpi", 160.0),
	TVDPI("tvdpi", 213.0),
	HDPI("hdpi", 240.0),
	XHDPI("xhdpi", 320.0),
	XXHDPI("xxhdpi", 480.0),
	XXXHDPI("xxxhdpi", 640.0);

	private final String qualifier;
	private final double value;

	public static final Ordering<Density> ORDERING = Ordering.natural();

	Density(String qualifier, double value) {
	this.qualifier = qualifier;
	this.value = value;
	}

	public double value() {
	return value;
	}

	@Override
	public String toString() {
	return qualifier;
	}

	public static Density from(String s) {
	return s.isEmpty() ? NO_QUALIFIER : valueOf(s.toUpperCase());
	}

	public static boolean isDensity(String s) {
	for (Density choice : values()) {
	if (choice.toString().equals(s)) {
	return true;
	}
	}
	return false;
	}
	}

	public static class Qualifiers {
	/** e.g. "xhdpi" */
	public final Filters.Density density;
	/** e.g. "de-v11" */
	public final String others;

	/**
	* Splits off the density qualifier from a drawable.
	* @param path path to a drawable
	*/
	public Qualifiers(Path path) {
	Filters.Density density = Density.NO_QUALIFIER;
	StringBuilder othersBuilder = new StringBuilder();
	for (String qualifier : path.getParent().getFileName().toString().split("-")) {
	if (qualifier.equals("drawable")) { // We're assuming they're all drawables.
	continue;
	}

	if (Filters.Density.isDensity(qualifier)) {
	density = Density.from(qualifier);
	} else {
	othersBuilder.append((MoreStrings.isEmpty(othersBuilder) ? "" : "-") + qualifier);
	}

	}
	this.density = density;
	this.others = othersBuilder.toString();
	}
	}

	/**
	* Takes a list of image files (as paths), and a target density (mdpi, hdpi, xhdpi), and
	* returns a list of files which can be safely left out when building an APK for phones with that
	* screen density. That APK will run on other screens as well but look worse due to scaling.
	* <p>
	* Each combination of non-density qualifiers is processed separately. For example, if we have
	* {@code drawable-hdpi, drawable-mdpi, drawable-xhdpi, drawable-hdpi-ro}, for a target of {@code
	* mdpi}, we'll be keeping {@code drawable-mdpi, drawable-hdpi-ro}.
	* @param candidates list of paths to image files
	* @param targetDensities densities we want to keep
	* @param canDownscale do we have access to an image scaler
	* @return set of files to remove
	*/
	@VisibleForTesting
	static Set<Path> filterByDensity(
	Collection<Path> candidates,
	Set<Filters.Density> targetDensities,
	boolean canDownscale) {
	ImmutableSet.Builder<Path> removals = ImmutableSet.builder();

	Table<String, Density, Path> imageValues = HashBasedTable.create();

	// Create mappings for drawables. If candidate == "<base>/drawable-<dpi>-<other>/<filename>",
	// then we'll record a mapping of the form ("<base>/<filename>/<other>", "<dpi>") -> candidate.
	// For example:
	// mdpi hdpi
	// --------------------------------------------------------------------
	// key: res/some.png/ \| res/drawable-mdpi/some.png res/drawable-hdpi/some.png
	// key: res/some.png/fr \| res/drawable-fr-hdpi/some.png
	for (Path candidate : candidates) {
	Qualifiers qualifiers = new Qualifiers(candidate);

	String filename = candidate.getFileName().toString();
	Density density = qualifiers.density;
	String resDirectory = candidate.getParent().getParent().toString();
	String key = String.format("%s/%s/%s", resDirectory, filename, qualifiers.others);
	imageValues.put(key, density, candidate);
	}

	for (String key : imageValues.rowKeySet()) {
	Map<Density, Path> options = imageValues.row(key);
	Set<Density> available = options.keySet();

	// This is to make sure we preserve the existing structure of drawable/ files.
	Set<Density> targets = targetDensities;
	if (available.contains(Density.NO_QUALIFIER) && !available.contains(Density.MDPI)) {
	targets = Sets.newHashSet(Iterables.transform(targetDensities,
	new Function<Density, Density>() {
	@Override
	public Density apply(Density input) {
	return (input == Density.MDPI) ? Density.NO_QUALIFIER : input;
	}
	}));
	}

	// We intend to keep all available targeted densities.
	Set<Density> toKeep = Sets.newHashSet(Sets.intersection(available, targets));

	// Make sure we have a decent fit for the largest target density.
	Density largestTarget = Density.ORDERING.max(targets);
	if (!available.contains(largestTarget)) {
	Density fallback = null;
	// Downscaling nine-patch drawables would require extra logic, not doing that yet.
	if (canDownscale && !options.values().iterator().next().toString().endsWith(".9.png")) {
	// Highest possible quality, because we'll downscale it.
	fallback = Density.ORDERING.max(available);
	} else {
	// We want to minimize size, so we'll go for the smallest available density that's
	// still larger than the missing one and, missing that, for the largest available.
	for (Density candidate : Density.ORDERING.reverse().sortedCopy(available)) {
	if (fallback == null \|\| Density.ORDERING.compare(candidate, largestTarget) > 0) {
	fallback = candidate;
	}
	}
	}
	toKeep.add(fallback);
	}

	// Mark remaining densities for removal.
	for (Density density : Sets.difference(available, toKeep)) {
	removals.add(options.get(density));
	}
	}

	return removals.build();
	}

	/**
	* Given a list of paths of available drawables, and a target screen density, returns a
	* {@link com.google.common.base.Predicate} that fails for drawables of a different
	* density, whenever they can be safely removed.
	* @param candidates list of available drawables
	* @param targetDensities set of e.g. {@code "mdpi"}, {@code "ldpi"} etc.
	* @param canDownscale if no exact match is available, retain the highest quality
	* @return a predicate as above
	*/
	public static Predicate<Path> createImageDensityFilter(
	Collection<Path> candidates,
	Set<Filters.Density> targetDensities,
	boolean canDownscale) {
	final Set<Path> pathsToRemove = filterByDensity(candidates, targetDensities, canDownscale);
	return new Predicate<Path>() {
	@Override
	public boolean apply(Path path) {
	return !pathsToRemove.contains(path);
	}
	};
	}
	}