tools/image_generator/ImageGenerator.java - android_bootable_recovery - Gitiles

 /*
  * Copyright (C) 2018 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.recovery.tools;

 import java.awt.Color;
 import java.awt.Font;
 import java.awt.FontFormatException;
 import java.awt.FontMetrics;
 import java.awt.Graphics2D;
 import java.awt.RenderingHints;
 import java.awt.image.BufferedImage;
 import java.io.File;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
 import java.util.TreeMap;
 import java.util.StringTokenizer;

 import javax.imageio.ImageIO;
 import javax.xml.parsers.DocumentBuilder;
 import javax.xml.parsers.DocumentBuilderFactory;
 import javax.xml.parsers.ParserConfigurationException;

 import org.apache.commons.cli.CommandLine;
 import org.apache.commons.cli.GnuParser;
 import org.apache.commons.cli.HelpFormatter;
 import org.apache.commons.cli.OptionBuilder;
 import org.apache.commons.cli.Options;
 import org.apache.commons.cli.ParseException;

 import org.w3c.dom.Document;
 import org.w3c.dom.Node;
 import org.w3c.dom.NodeList;

 /**
  * Command line tool to generate the localized image for recovery mode.
  */
 public class ImageGenerator {
   // Initial height of the image to draw.
   private static final int INITIAL_HEIGHT = 20000;

   private static final float DEFAULT_FONT_SIZE = 40;

   // This is the canvas we used to draw texts.
   private BufferedImage mBufferedImage;

   // The width in pixels of our image. Once set, its value won't change.
   private final int mImageWidth;

   // The current height in pixels of our image. We will adjust the value when drawing more texts.
   private int mImageHeight;

   // The current vertical offset in pixels to draw the top edge of new text strings.
   private int mVerticalOffset;

   // The font size to draw the texts.
   private final float mFontSize;

   // The name description of the text to localize. It's used to find the translated strings in the
   // resource file.
   private final String mTextName;

   // The directory that contains all the needed font files (e.g. ttf, otf, ttc files).
   private final String mFontDirPath;

   // An explicit map from language to the font name to use.
   // The map is extracted from frameworks/base/data/fonts/fonts.xml.
   // And the language-subtag-registry is found in:
   // https://www.iana.org/assignments/language-subtag-registry/language-subtag-registry
   private static final String DEFAULT_FONT_NAME = "Roboto-Regular";
   private static final Map<String, String> LANGUAGE_TO_FONT_MAP = new TreeMap<String, String>() {{
     put("am", "NotoSansEthiopic-Regular");
     put("ar", "NotoNaskhArabicUI-Regular");
     put("as", "NotoSansBengaliUI-Regular");
     put("bn", "NotoSansBengaliUI-Regular");
     put("fa", "NotoNaskhArabicUI-Regular");
     put("gu", "NotoSansGujaratiUI-Regular");
     put("hi", "NotoSansDevanagariUI-Regular");
     put("hy", "NotoSansArmenian-Regular");
     put("iw", "NotoSansHebrew-Regular");
     put("ja", "NotoSansCJK-Regular");
     put("ka", "NotoSansGeorgian-Regular");
     put("ko", "NotoSansCJK-Regular");
     put("km", "NotoSansKhmerUI-Regular");
     put("kn", "NotoSansKannadaUI-Regular");
     put("lo", "NotoSansLaoUI-Regular");
     put("ml", "NotoSansMalayalamUI-Regular");
     put("mr", "NotoSansDevanagariUI-Regular");
     put("my", "NotoSansMyanmarUI-Regular");
     put("ne", "NotoSansDevanagariUI-Regular");
     put("or", "NotoSansOriya-Regular");
     put("pa", "NotoSansGurmukhiUI-Regular");
     put("si", "NotoSansSinhala-Regular");
     put("ta", "NotoSansTamilUI-Regular");
     put("te", "NotoSansTeluguUI-Regular");
     put("th", "NotoSansThaiUI-Regular");
     put("ur", "NotoNaskhArabicUI-Regular");
     put("zh", "NotoSansCJK-Regular");
   }};

   /**
    * Exception to indicate the failure to find the translated text strings.
    */
   public static class LocalizedStringNotFoundException extends Exception {
     public LocalizedStringNotFoundException(String message) {
       super(message);
     }

     public LocalizedStringNotFoundException(String message, Throwable cause) {
       super(message, cause);
     }
   }

   /**
    * Initailizes the fields of the image image.
    */
   public ImageGenerator(int imageWidth, String textName, float fontSize, String fontDirPath) {
     mImageWidth = imageWidth;
     mImageHeight = INITIAL_HEIGHT;
     mVerticalOffset = 0;

     // Initialize the canvas with the default height.
     mBufferedImage = new BufferedImage(mImageWidth, mImageHeight, BufferedImage.TYPE_BYTE_GRAY);

     mTextName = textName;
     mFontSize = fontSize;
     mFontDirPath = fontDirPath;
   }

   /**
    * Finds the translated text string for the given textName by parsing the resourceFile.
    * Example of the xml fields:
    * <resources xmlns:android="http://schemas.android.com/apk/res/android">
    *   <string name="recovery_installing_security" msgid="9184031299717114342">
    * "Sicherheitsupdate wird installiert"</string>
    * </resources>
    *
    * @param resourceFile the input resource file in xml format.
    * @param textName the name description of the text.
    *
    * @return the string representation of the translated text.
    */
   private String getTextString(File resourceFile, String textName) throws IOException,
       ParserConfigurationException, org.xml.sax.SAXException, LocalizedStringNotFoundException {
     DocumentBuilderFactory builder = DocumentBuilderFactory.newInstance();
     DocumentBuilder db = builder.newDocumentBuilder();

     Document doc = db.parse(resourceFile);
     doc.getDocumentElement().normalize();

     NodeList nodeList = doc.getElementsByTagName("string");
     for (int i = 0; i < nodeList.getLength(); i++) {
       Node node = nodeList.item(i);
       String name = node.getAttributes().getNamedItem("name").getNodeValue();
       if (name.equals(textName)) {
         return node.getTextContent();
       }
     }

     throw new LocalizedStringNotFoundException(textName + " not found in "
         + resourceFile.getName());
   }

   /**
    * Constructs the locale from the name of the resource file.
    */
   private Locale getLocaleFromFilename(String filename) throws IOException {
     // Gets the locale string by trimming the top "values-".
     String localeString = filename.substring(7);
     if (localeString.matches("[A-Za-z]+")) {
       return Locale.forLanguageTag(localeString);
     }
     if (localeString.matches("[A-Za-z]+-r[A-Za-z]+")) {
       // "${Language}-r${Region}". e.g. en-rGB
       String[] tokens = localeString.split("-r");
       return Locale.forLanguageTag(String.join("-", tokens));
     }
     if (localeString.startsWith("b+")) {
       // The special case of b+sr+Latn, which has the form "b+${Language}+${ScriptName}"
       String[] tokens = localeString.substring(2).split("\\+");
       return Locale.forLanguageTag(String.join("-", tokens));
     }

     throw new IOException("Unrecognized locale string " + localeString);
   }

   /**
    * Iterates over the xml files in the format of values-$LOCALE/strings.xml under the resource
    * directory and collect the translated text.
    *
    * @param resourcePath the path to the resource directory
    *
    * @return a map with the locale as key, and translated text as value
    *
    * @throws LocalizedStringNotFoundException if we cannot find the translated text for the given
    *    locale
    **/
   public Map<Locale, String> readLocalizedStringFromXmls(String resourcePath) throws
       IOException, LocalizedStringNotFoundException {
     File resourceDir = new File(resourcePath);
     if (!resourceDir.isDirectory()) {
       throw new LocalizedStringNotFoundException(resourcePath + " is not a directory.");
     }

     Map<Locale, String> result =
         new TreeMap<Locale, String>(Comparator.comparing(Locale::toLanguageTag));

     // Find all the localized resource subdirectories in the format of values-$LOCALE
     String[] nameList = resourceDir.list(
         (File file, String name) -> name.startsWith("values-"));
     for (String name : nameList) {
       File textFile = new File(resourcePath, name + "/strings.xml");
       String localizedText;
       try {
         localizedText = getTextString(textFile, mTextName);
       } catch (IOException | ParserConfigurationException | org.xml.sax.SAXException e) {
         throw new LocalizedStringNotFoundException(
             "Failed to read the translated text for locale " + name, e);
       }

       Locale locale = getLocaleFromFilename(name);
       // Removes the double quotation mark from the text.
       result.put(locale, localizedText.substring(1, localizedText.length() - 1));
     }

     return result;
   }

   /**
    * Returns a font object associated given the given locale
    *
    * @throws IOException if the font file fails to open
    * @throws FontFormatException if the font file doesn't have the expected format
    */
   private Font loadFontsByLocale(String language) throws IOException, FontFormatException {
     String fontName = LANGUAGE_TO_FONT_MAP.getOrDefault(language, DEFAULT_FONT_NAME);
     String[] suffixes = {".otf", ".ttf", ".ttc"};
     for (String suffix : suffixes ) {
       File fontFile = new File(mFontDirPath, fontName + suffix);
       if (fontFile.isFile()) {
         return Font.createFont(Font.TRUETYPE_FONT, fontFile).deriveFont(mFontSize);
       }
     }

     throw new IOException("Can not find the font file " + fontName + " for language " + language);
   }

   /**
    * Separates the text string by spaces and wraps it by words.
   **/
   private List<String> wrapTextByWords(String text, FontMetrics metrics) {
     List<String> wrappedText = new ArrayList<>();
     StringTokenizer st = new StringTokenizer(text, " \n");

     StringBuilder line = new StringBuilder();
     while (st.hasMoreTokens()) {
       String token = st.nextToken();
       if (metrics.stringWidth(line + token + " ") > mImageWidth) {
         wrappedText.add(line.toString());
         line = new StringBuilder();
       }
       line.append(token).append(" ");
     }
     wrappedText.add(line.toString());

     return wrappedText;
   }

   /**
    * Wraps the text with a maximum of mImageWidth pixels per line.
    *
    * @param text the string representation of text to wrap
    * @param metrics the metrics of the Font used to draw the text; it gives the width in pixels of
    *    the text given its string representation
    *
    * @return a list of strings with their width smaller than mImageWidth pixels
    */
   private List<String> wrapText(String text, FontMetrics metrics) {
     // TODO(xunchang) handle other cases of text wrapping
     // 1. RTL languages: "ar"(Arabic), "fa"(Persian), "he"(Hebrew), "iw"(Hebrew), "ur"(Urdu)
     // 2. Language uses characters: CJK, "lo"(lao), "km"(khmer)

     return wrapTextByWords(text, metrics);
   }

   /**
    * Draws the text string on the canvas for given locale.
    *
    * @param text the string to draw on canvas
    * @param locale the current locale tag of the string to draw
    *
    * @throws IOException if we cannot find the corresponding font file for the given locale.
    * @throws FontFormatException if we failed to load the font file for the given locale.
    */
   private void drawText(String text, Locale locale) throws IOException, FontFormatException  {
     Graphics2D graphics = mBufferedImage.createGraphics();
     graphics.setColor(Color.WHITE);
     graphics.setRenderingHint(
         RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_GASP);
     graphics.setFont(loadFontsByLocale(locale.getLanguage()));

     System.out.println("Drawing text for locale " + locale + " text " + text);

     FontMetrics fontMetrics = graphics.getFontMetrics();
     List<String> wrappedText = wrapTextByWords(text, fontMetrics);
     for (String line : wrappedText) {
       int lineHeight = fontMetrics.getHeight();
       // Doubles the height of the image if we are short of space.
       if (mVerticalOffset + lineHeight >= mImageHeight) {
         resizeHeight(mImageHeight * 2);
       }

       // Draws the text at mVerticalOffset and increments the offset with line space.
       int baseLine = mVerticalOffset + lineHeight - fontMetrics.getDescent();
       graphics.drawString(line, 0, baseLine);
       mVerticalOffset += lineHeight;
     }
   }

   /**
    * Redraws the image with the new height.
    *
    * @param height the new height of the image in pixels.
    */
   private void resizeHeight(int height) {
     BufferedImage resizedImage =
         new BufferedImage(mImageWidth, height, BufferedImage.TYPE_BYTE_GRAY);
     Graphics2D graphic = resizedImage.createGraphics();
     graphic.drawImage(mBufferedImage, 0, 0, null);
     graphic.dispose();

     mBufferedImage = resizedImage;
     mImageHeight = height;
   }

   /**
    *  This function draws the font characters and saves the result to outputPath.
    *
    * @param localizedTextMap a map from locale to its translated text string
    * @param outputPath the path to write the generated image file.
    *
    * @throws FontFormatException if there's a format error in one of the font file
    * @throws IOException if we cannot find the font file for one of the locale, or we failed to
    *    write the image file.
    */
   public void generateImage(Map<Locale, String> localizedTextMap, String outputPath) throws
       FontFormatException, IOException {
     for (Locale locale : localizedTextMap.keySet()) {
       // TODO(xunchang) reprocess the locales for the same language and make the last locale the
       // catch-all type. e.g. "zh-CN, zh-HK, zh-TW" will become "zh-CN, zh-HK, zh"
       // Or maybe we don't need to support these variants?
       drawText(localizedTextMap.get(locale), locale);
     }

     // TODO(xunchang) adjust the width to save some space if all texts are smaller than imageWidth.
     resizeHeight(mVerticalOffset);
     ImageIO.write(mBufferedImage, "png", new File(outputPath));
   }

   public static void printUsage(Options options) {
     new HelpFormatter().printHelp("java -jar path_to_jar [required_options]", options);

   }

   public static Options createOptions() {
     Options options = new Options();
     options.addOption(OptionBuilder
         .withLongOpt("image_width")
         .withDescription("The initial width of the image in pixels.")
         .hasArgs(1)
         .isRequired()
         .create());

     options.addOption(OptionBuilder
         .withLongOpt("text_name")
         .withDescription("The description of the text string, e.g. recovery_erasing")
         .hasArgs(1)
         .isRequired()
         .create());

     options.addOption(OptionBuilder
         .withLongOpt("font_dir")
         .withDescription("The directory that contains all the support font format files, e.g."
             + " $OUT/system/fonts/")
         .hasArgs(1)
         .isRequired()
         .create());

     options.addOption(OptionBuilder
         .withLongOpt("resource_dir")
         .withDescription("The resource directory that contains all the translated strings in xml"
             + " format, e.g. bootable/recovery/tools/recovery_l10n/res/")
         .hasArgs(1)
         .isRequired()
         .create());

     options.addOption(OptionBuilder
         .withLongOpt("output_file")
         .withDescription("Path to the generated image")
         .hasArgs(1)
         .isRequired()
         .create());

     return options;
   }

   public static void main(String[] args) throws NumberFormatException, IOException,
       FontFormatException, LocalizedStringNotFoundException {
     Options options = createOptions();
     CommandLine cmd;
     try {
       cmd = new GnuParser().parse(options, args);
     } catch (ParseException e) {
       System.err.println(e.getMessage());
       printUsage(options);
       return;
     }

     int imageWidth = Integer.parseUnsignedInt(cmd.getOptionValue("image_width"));

     ImageGenerator imageGenerator = new ImageGenerator(imageWidth, cmd.getOptionValue("text_name"),
         DEFAULT_FONT_SIZE, cmd.getOptionValue("font_dir"));

     Map<Locale, String> localizedStringMap =
         imageGenerator.readLocalizedStringFromXmls(cmd.getOptionValue("resource_dir"));
     imageGenerator.generateImage(localizedStringMap, cmd.getOptionValue("output_file"));
   }
 }
	/*
	* Copyright (C) 2018 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.recovery.tools;

	import java.awt.Color;
	import java.awt.Font;
	import java.awt.FontFormatException;
	import java.awt.FontMetrics;
	import java.awt.Graphics2D;
	import java.awt.RenderingHints;
	import java.awt.image.BufferedImage;
	import java.io.File;
	import java.io.IOException;
	import java.util.ArrayList;
	import java.util.Comparator;
	import java.util.List;
	import java.util.Locale;
	import java.util.Map;
	import java.util.TreeMap;
	import java.util.StringTokenizer;

	import javax.imageio.ImageIO;
	import javax.xml.parsers.DocumentBuilder;
	import javax.xml.parsers.DocumentBuilderFactory;
	import javax.xml.parsers.ParserConfigurationException;

	import org.apache.commons.cli.CommandLine;
	import org.apache.commons.cli.GnuParser;
	import org.apache.commons.cli.HelpFormatter;
	import org.apache.commons.cli.OptionBuilder;
	import org.apache.commons.cli.Options;
	import org.apache.commons.cli.ParseException;

	import org.w3c.dom.Document;
	import org.w3c.dom.Node;
	import org.w3c.dom.NodeList;

	/**
	* Command line tool to generate the localized image for recovery mode.
	*/
	public class ImageGenerator {
	// Initial height of the image to draw.
	private static final int INITIAL_HEIGHT = 20000;

	private static final float DEFAULT_FONT_SIZE = 40;

	// This is the canvas we used to draw texts.
	private BufferedImage mBufferedImage;

	// The width in pixels of our image. Once set, its value won't change.
	private final int mImageWidth;

	// The current height in pixels of our image. We will adjust the value when drawing more texts.
	private int mImageHeight;

	// The current vertical offset in pixels to draw the top edge of new text strings.
	private int mVerticalOffset;

	// The font size to draw the texts.
	private final float mFontSize;

	// The name description of the text to localize. It's used to find the translated strings in the
	// resource file.
	private final String mTextName;

	// The directory that contains all the needed font files (e.g. ttf, otf, ttc files).
	private final String mFontDirPath;

	// An explicit map from language to the font name to use.
	// The map is extracted from frameworks/base/data/fonts/fonts.xml.
	// And the language-subtag-registry is found in:
	// https://www.iana.org/assignments/language-subtag-registry/language-subtag-registry
	private static final String DEFAULT_FONT_NAME = "Roboto-Regular";
	private static final Map<String, String> LANGUAGE_TO_FONT_MAP = new TreeMap<String, String>() {{
	put("am", "NotoSansEthiopic-Regular");
	put("ar", "NotoNaskhArabicUI-Regular");
	put("as", "NotoSansBengaliUI-Regular");
	put("bn", "NotoSansBengaliUI-Regular");
	put("fa", "NotoNaskhArabicUI-Regular");
	put("gu", "NotoSansGujaratiUI-Regular");
	put("hi", "NotoSansDevanagariUI-Regular");
	put("hy", "NotoSansArmenian-Regular");
	put("iw", "NotoSansHebrew-Regular");
	put("ja", "NotoSansCJK-Regular");
	put("ka", "NotoSansGeorgian-Regular");
	put("ko", "NotoSansCJK-Regular");
	put("km", "NotoSansKhmerUI-Regular");
	put("kn", "NotoSansKannadaUI-Regular");
	put("lo", "NotoSansLaoUI-Regular");
	put("ml", "NotoSansMalayalamUI-Regular");
	put("mr", "NotoSansDevanagariUI-Regular");
	put("my", "NotoSansMyanmarUI-Regular");
	put("ne", "NotoSansDevanagariUI-Regular");
	put("or", "NotoSansOriya-Regular");
	put("pa", "NotoSansGurmukhiUI-Regular");
	put("si", "NotoSansSinhala-Regular");
	put("ta", "NotoSansTamilUI-Regular");
	put("te", "NotoSansTeluguUI-Regular");
	put("th", "NotoSansThaiUI-Regular");
	put("ur", "NotoNaskhArabicUI-Regular");
	put("zh", "NotoSansCJK-Regular");
	}};

	/**
	* Exception to indicate the failure to find the translated text strings.
	*/
	public static class LocalizedStringNotFoundException extends Exception {
	public LocalizedStringNotFoundException(String message) {
	super(message);
	}

	public LocalizedStringNotFoundException(String message, Throwable cause) {
	super(message, cause);
	}
	}

	/**
	* Initailizes the fields of the image image.
	*/
	public ImageGenerator(int imageWidth, String textName, float fontSize, String fontDirPath) {
	mImageWidth = imageWidth;
	mImageHeight = INITIAL_HEIGHT;
	mVerticalOffset = 0;

	// Initialize the canvas with the default height.
	mBufferedImage = new BufferedImage(mImageWidth, mImageHeight, BufferedImage.TYPE_BYTE_GRAY);

	mTextName = textName;
	mFontSize = fontSize;
	mFontDirPath = fontDirPath;
	}

	/**
	* Finds the translated text string for the given textName by parsing the resourceFile.
	* Example of the xml fields:
	* <resources xmlns:android="http://schemas.android.com/apk/res/android">
	* <string name="recovery_installing_security" msgid="9184031299717114342">
	* "Sicherheitsupdate wird installiert"</string>
	* </resources>
	*
	* @param resourceFile the input resource file in xml format.
	* @param textName the name description of the text.
	*
	* @return the string representation of the translated text.
	*/
	private String getTextString(File resourceFile, String textName) throws IOException,
	ParserConfigurationException, org.xml.sax.SAXException, LocalizedStringNotFoundException {
	DocumentBuilderFactory builder = DocumentBuilderFactory.newInstance();
	DocumentBuilder db = builder.newDocumentBuilder();

	Document doc = db.parse(resourceFile);
	doc.getDocumentElement().normalize();

	NodeList nodeList = doc.getElementsByTagName("string");
	for (int i = 0; i < nodeList.getLength(); i++) {
	Node node = nodeList.item(i);
	String name = node.getAttributes().getNamedItem("name").getNodeValue();
	if (name.equals(textName)) {
	return node.getTextContent();
	}
	}

	throw new LocalizedStringNotFoundException(textName + " not found in "
	+ resourceFile.getName());
	}

	/**
	* Constructs the locale from the name of the resource file.
	*/
	private Locale getLocaleFromFilename(String filename) throws IOException {
	// Gets the locale string by trimming the top "values-".
	String localeString = filename.substring(7);
	if (localeString.matches("[A-Za-z]+")) {
	return Locale.forLanguageTag(localeString);
	}
	if (localeString.matches("[A-Za-z]+-r[A-Za-z]+")) {
	// "${Language}-r${Region}". e.g. en-rGB
	String[] tokens = localeString.split("-r");
	return Locale.forLanguageTag(String.join("-", tokens));
	}
	if (localeString.startsWith("b+")) {
	// The special case of b+sr+Latn, which has the form "b+${Language}+${ScriptName}"
	String[] tokens = localeString.substring(2).split("\\+");
	return Locale.forLanguageTag(String.join("-", tokens));
	}

	throw new IOException("Unrecognized locale string " + localeString);
	}

	/**
	* Iterates over the xml files in the format of values-$LOCALE/strings.xml under the resource
	* directory and collect the translated text.
	*
	* @param resourcePath the path to the resource directory
	*
	* @return a map with the locale as key, and translated text as value
	*
	* @throws LocalizedStringNotFoundException if we cannot find the translated text for the given
	* locale
	**/
	public Map<Locale, String> readLocalizedStringFromXmls(String resourcePath) throws
	IOException, LocalizedStringNotFoundException {
	File resourceDir = new File(resourcePath);
	if (!resourceDir.isDirectory()) {
	throw new LocalizedStringNotFoundException(resourcePath + " is not a directory.");
	}

	Map<Locale, String> result =
	new TreeMap<Locale, String>(Comparator.comparing(Locale::toLanguageTag));

	// Find all the localized resource subdirectories in the format of values-$LOCALE
	String[] nameList = resourceDir.list(
	(File file, String name) -> name.startsWith("values-"));
	for (String name : nameList) {
	File textFile = new File(resourcePath, name + "/strings.xml");
	String localizedText;
	try {
	localizedText = getTextString(textFile, mTextName);
	} catch (IOException \| ParserConfigurationException \| org.xml.sax.SAXException e) {
	throw new LocalizedStringNotFoundException(
	"Failed to read the translated text for locale " + name, e);
	}

	Locale locale = getLocaleFromFilename(name);
	// Removes the double quotation mark from the text.
	result.put(locale, localizedText.substring(1, localizedText.length() - 1));
	}

	return result;
	}

	/**
	* Returns a font object associated given the given locale
	*
	* @throws IOException if the font file fails to open
	* @throws FontFormatException if the font file doesn't have the expected format
	*/
	private Font loadFontsByLocale(String language) throws IOException, FontFormatException {
	String fontName = LANGUAGE_TO_FONT_MAP.getOrDefault(language, DEFAULT_FONT_NAME);
	String[] suffixes = {".otf", ".ttf", ".ttc"};
	for (String suffix : suffixes ) {
	File fontFile = new File(mFontDirPath, fontName + suffix);
	if (fontFile.isFile()) {
	return Font.createFont(Font.TRUETYPE_FONT, fontFile).deriveFont(mFontSize);
	}
	}

	throw new IOException("Can not find the font file " + fontName + " for language " + language);
	}

	/**
	* Separates the text string by spaces and wraps it by words.
	**/
	private List<String> wrapTextByWords(String text, FontMetrics metrics) {
	List<String> wrappedText = new ArrayList<>();
	StringTokenizer st = new StringTokenizer(text, " \n");

	StringBuilder line = new StringBuilder();
	while (st.hasMoreTokens()) {
	String token = st.nextToken();
	if (metrics.stringWidth(line + token + " ") > mImageWidth) {
	wrappedText.add(line.toString());
	line = new StringBuilder();
	}
	line.append(token).append(" ");
	}
	wrappedText.add(line.toString());

	return wrappedText;
	}

	/**
	* Wraps the text with a maximum of mImageWidth pixels per line.
	*
	* @param text the string representation of text to wrap
	* @param metrics the metrics of the Font used to draw the text; it gives the width in pixels of
	* the text given its string representation
	*
	* @return a list of strings with their width smaller than mImageWidth pixels
	*/
	private List<String> wrapText(String text, FontMetrics metrics) {
	// TODO(xunchang) handle other cases of text wrapping
	// 1. RTL languages: "ar"(Arabic), "fa"(Persian), "he"(Hebrew), "iw"(Hebrew), "ur"(Urdu)
	// 2. Language uses characters: CJK, "lo"(lao), "km"(khmer)

	return wrapTextByWords(text, metrics);
	}

	/**
	* Draws the text string on the canvas for given locale.
	*
	* @param text the string to draw on canvas
	* @param locale the current locale tag of the string to draw
	*
	* @throws IOException if we cannot find the corresponding font file for the given locale.
	* @throws FontFormatException if we failed to load the font file for the given locale.
	*/
	private void drawText(String text, Locale locale) throws IOException, FontFormatException {
	Graphics2D graphics = mBufferedImage.createGraphics();
	graphics.setColor(Color.WHITE);
	graphics.setRenderingHint(
	RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_GASP);
	graphics.setFont(loadFontsByLocale(locale.getLanguage()));

	System.out.println("Drawing text for locale " + locale + " text " + text);

	FontMetrics fontMetrics = graphics.getFontMetrics();
	List<String> wrappedText = wrapTextByWords(text, fontMetrics);
	for (String line : wrappedText) {
	int lineHeight = fontMetrics.getHeight();
	// Doubles the height of the image if we are short of space.
	if (mVerticalOffset + lineHeight >= mImageHeight) {
	resizeHeight(mImageHeight * 2);
	}

	// Draws the text at mVerticalOffset and increments the offset with line space.
	int baseLine = mVerticalOffset + lineHeight - fontMetrics.getDescent();
	graphics.drawString(line, 0, baseLine);
	mVerticalOffset += lineHeight;
	}
	}

	/**
	* Redraws the image with the new height.
	*
	* @param height the new height of the image in pixels.
	*/
	private void resizeHeight(int height) {
	BufferedImage resizedImage =
	new BufferedImage(mImageWidth, height, BufferedImage.TYPE_BYTE_GRAY);
	Graphics2D graphic = resizedImage.createGraphics();
	graphic.drawImage(mBufferedImage, 0, 0, null);
	graphic.dispose();

	mBufferedImage = resizedImage;
	mImageHeight = height;
	}

	/**
	* This function draws the font characters and saves the result to outputPath.
	*
	* @param localizedTextMap a map from locale to its translated text string
	* @param outputPath the path to write the generated image file.
	*
	* @throws FontFormatException if there's a format error in one of the font file
	* @throws IOException if we cannot find the font file for one of the locale, or we failed to
	* write the image file.
	*/
	public void generateImage(Map<Locale, String> localizedTextMap, String outputPath) throws
	FontFormatException, IOException {
	for (Locale locale : localizedTextMap.keySet()) {
	// TODO(xunchang) reprocess the locales for the same language and make the last locale the
	// catch-all type. e.g. "zh-CN, zh-HK, zh-TW" will become "zh-CN, zh-HK, zh"
	// Or maybe we don't need to support these variants?
	drawText(localizedTextMap.get(locale), locale);
	}

	// TODO(xunchang) adjust the width to save some space if all texts are smaller than imageWidth.
	resizeHeight(mVerticalOffset);
	ImageIO.write(mBufferedImage, "png", new File(outputPath));
	}

	public static void printUsage(Options options) {
	new HelpFormatter().printHelp("java -jar path_to_jar [required_options]", options);

	}

	public static Options createOptions() {
	Options options = new Options();
	options.addOption(OptionBuilder
	.withLongOpt("image_width")
	.withDescription("The initial width of the image in pixels.")
	.hasArgs(1)
	.isRequired()
	.create());

	options.addOption(OptionBuilder
	.withLongOpt("text_name")
	.withDescription("The description of the text string, e.g. recovery_erasing")
	.hasArgs(1)
	.isRequired()
	.create());

	options.addOption(OptionBuilder
	.withLongOpt("font_dir")
	.withDescription("The directory that contains all the support font format files, e.g."
	+ " $OUT/system/fonts/")
	.hasArgs(1)
	.isRequired()
	.create());

	options.addOption(OptionBuilder
	.withLongOpt("resource_dir")
	.withDescription("The resource directory that contains all the translated strings in xml"
	+ " format, e.g. bootable/recovery/tools/recovery_l10n/res/")
	.hasArgs(1)
	.isRequired()
	.create());

	options.addOption(OptionBuilder
	.withLongOpt("output_file")
	.withDescription("Path to the generated image")
	.hasArgs(1)
	.isRequired()
	.create());

	return options;
	}

	public static void main(String[] args) throws NumberFormatException, IOException,
	FontFormatException, LocalizedStringNotFoundException {
	Options options = createOptions();
	CommandLine cmd;
	try {
	cmd = new GnuParser().parse(options, args);
	} catch (ParseException e) {
	System.err.println(e.getMessage());
	printUsage(options);
	return;
	}

	int imageWidth = Integer.parseUnsignedInt(cmd.getOptionValue("image_width"));

	ImageGenerator imageGenerator = new ImageGenerator(imageWidth, cmd.getOptionValue("text_name"),
	DEFAULT_FONT_SIZE, cmd.getOptionValue("font_dir"));

	Map<Locale, String> localizedStringMap =
	imageGenerator.readLocalizedStringFromXmls(cmd.getOptionValue("resource_dir"));
	imageGenerator.generateImage(localizedStringMap, cmd.getOptionValue("output_file"));
	}
	}