Java tutorial
/* * Copyright (C) 2011 The Android Open Source Project * * 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.android.assetstudiolib; import com.android.SdkConstants; import com.android.annotations.NonNull; import com.android.resources.Density; import com.android.resources.ResourceFolderType; import com.android.utils.SdkUtils; import com.google.common.collect.Lists; import com.google.common.io.Closeables; import java.awt.image.BufferedImage; import java.io.File; import java.io.IOException; import java.io.InputStream; import java.net.JarURLConnection; import java.net.URL; import java.net.URLConnection; import java.security.ProtectionDomain; import java.util.ArrayList; import java.util.Arrays; import java.util.Comparator; import java.util.Enumeration; import java.util.Iterator; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import java.util.jar.JarFile; import java.util.zip.ZipEntry; import java.util.zip.ZipFile; import javax.imageio.ImageIO; /** * The base Generator class. */ public abstract class GraphicGenerator { /** * Options used for all generators. */ public static class Options { /** Minimum version (API level) of the SDK to generate icons for */ public int minSdk = 1; /** Source image to use as a basis for the icon */ public BufferedImage sourceImage; /** The density to generate the icon with */ public Density density = Density.XHIGH; /** Whether the icon should be written out to the mipmap folder instead of drawable */ public boolean mipmap; } /** Shapes that can be used for icon backgrounds */ public enum Shape { /** No background */ NONE("none"), /** Circular background */ CIRCLE("circle"), /** Square background */ SQUARE("square"), /** Vertical rectangular background */ VRECT("vrect"), /** Horizontal rectangular background */ HRECT("hrect"), /** Square background with Dog-ear effect */ SQUARE_DOG("square_dogear"), /** Vertical rectangular background with Dog-ear effect */ VRECT_DOG("vrect_dogear"), /** Horizontal rectangular background with Dog-ear effect */ HRECT_DOG("hrect_dogear"); /** Id, used in filenames to identify associated stencils */ public final String id; Shape(String id) { this.id = id; } } /** Foreground effects styles */ public enum Style { /** No effects */ SIMPLE("fore1"); /** Id, used in filenames to identify associated stencils */ public final String id; Style(String id) { this.id = id; } } /** * Generate a single icon using the given options * * @param context render context to use for looking up resources etc * @param options options controlling the appearance of the icon * @return a {@link BufferedImage} with the generated icon */ public abstract BufferedImage generate(GraphicGeneratorContext context, Options options); /** * Computes the target filename (relative to the Android project folder) * where an icon rendered with the given options should be stored. This is * also used as the map keys in the result map used by * {@link #generate(String, Map, GraphicGeneratorContext, Options, String)}. * * @param options the options object used by the generator for the current * image * @param name the base name to use when creating the path * @return a path relative to the res/ folder where the image should be * stored (will always use / as a path separator, not \ on Windows) */ protected String getIconPath(Options options, String name) { return getIconFolder(options) + '/' + getIconName(options, name); } /** * Gets name of the file itself. It is sometimes modified by options, for * example in unselected tabs we change foo.png to foo-unselected.png */ protected String getIconName(Options options, String name) { if (options.density == Density.ANYDPI) { return name + SdkConstants.DOT_XML; } return name + SdkConstants.DOT_PNG; //$NON-NLS-1$ } /** * Gets name of the folder to contain the resource. It usually includes the * density, but is also sometimes modified by options. For example, in some * notification icons we add in -v9 or -v11. */ protected String getIconFolder(Options options) { if (options.density == Density.ANYDPI) { return SdkConstants.FD_RES + '/' + ResourceFolderType.DRAWABLE.getName(); } StringBuilder sb = new StringBuilder(50); sb.append(SdkConstants.FD_RES); sb.append('/'); if (options.mipmap) { sb.append(ResourceFolderType.MIPMAP.getName()); } else { sb.append(ResourceFolderType.DRAWABLE.getName()); } sb.append('-'); sb.append(options.density.getResourceValue()); return sb.toString(); } /** * Generates a full set of icons into the given map. The values in the map * will be the generated images, and each value is keyed by the * corresponding relative path of the image, which is determined by the * {@link #getIconPath(Options, String)} method. * * @param category the current category to place images into (if null the * density name will be used) * @param categoryMap the map to put images into, should not be null. The * map is a map from a category name, to a map from file path to * image. * @param context a generator context which for example can load resources * @param options options to apply to this generator * @param name the base name of the icons to generate */ public void generate(String category, Map<String, Map<String, BufferedImage>> categoryMap, GraphicGeneratorContext context, Options options, String name) { // Vector image only need to generate one preview image, so we by pass all the // other image densities. if (options.density == Density.ANYDPI) { generateImageAndUpdateMap(category, categoryMap, context, options, name); return; } Density[] densityValues = Density.values(); // Sort density values into ascending order Arrays.sort(densityValues, new Comparator<Density>() { @Override public int compare(Density d1, Density d2) { return d1.getDpiValue() - d2.getDpiValue(); } }); for (Density density : densityValues) { if (!density.isValidValueForDevice()) { continue; } if (!includeDensity(density)) { // Not yet supported -- missing stencil image // TODO don't manually check and instead gracefully handle missing stencils. continue; } options.density = density; generateImageAndUpdateMap(category, categoryMap, context, options, name); } } private void generateImageAndUpdateMap(String category, Map<String, Map<String, BufferedImage>> categoryMap, GraphicGeneratorContext context, Options options, String name) { BufferedImage image = generate(context, options); if (image != null) { String mapCategory = category; if (mapCategory == null) { mapCategory = options.density.getResourceValue(); } Map<String, BufferedImage> imageMap = categoryMap.get(mapCategory); if (imageMap == null) { imageMap = new LinkedHashMap<String, BufferedImage>(); categoryMap.put(mapCategory, imageMap); } imageMap.put(getIconPath(options, name), image); } } protected boolean includeDensity(@NonNull Density density) { return density.isRecommended() && density != Density.LOW && density != Density.XXXHIGH; } /** * Returns the scale factor to apply for a given MDPI density to compute the * absolute pixel count to use to draw an icon of the given target density * * @param density the density * @return a factor to multiple mdpi distances with to compute the target density */ public static float getMdpiScaleFactor(Density density) { if (density == Density.ANYDPI) { density = Density.XXXHIGH; } return density.getDpiValue() / (float) Density.MEDIUM.getDpiValue(); } /** * Returns one of the built in stencil images, or null * * @param relativePath stencil path such as "launcher-stencil/square/web/back.png" * @return the image, or null * @throws IOException if an unexpected I/O error occurs */ public static BufferedImage getStencilImage(String relativePath) throws IOException { InputStream is = GraphicGenerator.class.getResourceAsStream(relativePath); if (is == null) { return null; } try { return ImageIO.read(is); } finally { Closeables.close(is, true /* swallowIOException */); } } /** * Returns the icon (32x32) for a given clip art image. * * @param name the name of the image to be loaded (which can be looked up via * {@link #getClipartNames()}) * @return the icon image * @throws IOException if the image cannot be loaded */ public static BufferedImage getClipartIcon(String name) throws IOException { InputStream is = GraphicGenerator.class.getResourceAsStream("/images/clipart/small/" + name); try { return ImageIO.read(is); } finally { Closeables.close(is, true /* swallowIOException */); } } /** * Returns the full size clip art image for a given image name. * * @param name the name of the image to be loaded (which can be looked up via * {@link #getClipartNames()}) * @return the clip art image * @throws IOException if the image cannot be loaded */ public static BufferedImage getClipartImage(String name) throws IOException { InputStream is = GraphicGenerator.class.getResourceAsStream("/images/clipart/big/" + name); try { return ImageIO.read(is); } finally { Closeables.close(is, true /* swallowIOException */); } } /** * Returns the names of available clip art images which can be obtained by passing the * name to {@link #getClipartIcon(String)} or * {@link GraphicGenerator#getClipartImage(String)} * * @return an iterator for the available image names */ public static Iterator<String> getResourcesNames(String pathPrefix, String filenameExtension) { List<String> names = new ArrayList<String>(80); try { ZipFile zipFile = null; ProtectionDomain protectionDomain = GraphicGenerator.class.getProtectionDomain(); URL url = protectionDomain.getCodeSource().getLocation(); if (url != null) { File file = SdkUtils.urlToFile(url); zipFile = new JarFile(file); } else { Enumeration<URL> en = GraphicGenerator.class.getClassLoader().getResources(pathPrefix); if (en.hasMoreElements()) { url = en.nextElement(); URLConnection urlConnection = url.openConnection(); if (urlConnection instanceof JarURLConnection) { JarURLConnection urlConn = (JarURLConnection) (urlConnection); zipFile = urlConn.getJarFile(); } else if ("file".equals(url.getProtocol())) { //$NON-NLS-1$ File directory = new File(url.getPath()); return Lists.newArrayList(directory.list()).iterator(); } } } Enumeration<? extends ZipEntry> enumeration = zipFile.entries(); while (enumeration.hasMoreElements()) { ZipEntry zipEntry = enumeration.nextElement(); String name = zipEntry.getName(); if (!name.startsWith(pathPrefix) || !name.endsWith(filenameExtension)) { //$NON-NLS-1$ continue; } int lastSlash = name.lastIndexOf('/'); if (lastSlash != -1) { name = name.substring(lastSlash + 1); } names.add(name); } } catch (final Exception e) { e.printStackTrace(); } return names.iterator(); } }