com.google.zxing.StringsResourceTranslator Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of javase Show documentation
Show all versions of javase Show documentation
Java SE-specific extensions to core ZXing library
/*
* Copyright 2010 ZXing authors
*
* 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.zxing;
import java.io.BufferedReader;
import java.io.Closeable;
import java.io.File;
import java.io.FileFilter;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.Reader;
import java.io.Writer;
import java.net.URL;
import java.net.URLConnection;
import java.net.URLEncoder;
import java.nio.charset.Charset;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.SortedMap;
import java.util.TreeMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* A utility which auto-translates English strings in Android string resources using
* Google Translate.
*
* Pass the Android client res/ directory as first argument, and optionally message keys
* who should be forced to retranslate.
* Usage: {@code StringsResourceTranslator android/res/ [key_1 ...]}
*
* @author Sean Owen
*/
public final class StringsResourceTranslator {
private static final String API_KEY = "INSERT-YOUR-KEY";
private static final Charset UTF8 = Charset.forName("UTF-8");
private static final Pattern ENTRY_PATTERN = Pattern.compile("([^<]+) ");
private static final Pattern STRINGS_FILE_NAME_PATTERN = Pattern.compile("values-(.+)");
private static final Pattern TRANSLATE_RESPONSE_PATTERN = Pattern.compile("translatedText\":\\s*\"([^\"]+)\"");
private static final Pattern VALUES_DIR_PATTERN = Pattern.compile("values-[a-z]{2}(-[a-zA-Z]{2,3})?");
private static final String APACHE_2_LICENSE =
"\n";
private static final Map LANGUAGE_CODE_MASSAGINGS = new HashMap(3);
static {
LANGUAGE_CODE_MASSAGINGS.put("zh-rCN", "zh-cn");
LANGUAGE_CODE_MASSAGINGS.put("zh-rTW", "zh-tw");
}
private StringsResourceTranslator() {}
public static void main(String[] args) throws IOException {
File resDir = new File(args[0]);
File valueDir = new File(resDir, "values");
File stringsFile = new File(valueDir, "strings.xml");
Collection forceRetranslation = Arrays.asList(args).subList(1, args.length);
File[] translatedValuesDirs = resDir.listFiles(new FileFilter() {
@Override
public boolean accept(File file) {
return file.isDirectory() && VALUES_DIR_PATTERN.matcher(file.getName()).matches();
}
});
for (File translatedValuesDir : translatedValuesDirs) {
File translatedStringsFile = new File(translatedValuesDir, "strings.xml");
translate(stringsFile, translatedStringsFile, forceRetranslation);
}
}
private static void translate(File englishFile,
File translatedFile,
Collection forceRetranslation) throws IOException {
SortedMap english = readLines(englishFile);
SortedMap translated = readLines(translatedFile);
String parentName = translatedFile.getParentFile().getName();
Matcher stringsFileNameMatcher = STRINGS_FILE_NAME_PATTERN.matcher(parentName);
stringsFileNameMatcher.find();
String language = stringsFileNameMatcher.group(1);
String massagedLanguage = LANGUAGE_CODE_MASSAGINGS.get(language);
if (massagedLanguage != null) {
language = massagedLanguage;
}
System.out.println("Translating " + language);
File resultTempFile = File.createTempFile(parentName, ".xml");
boolean anyChange = false;
Writer out = null;
try {
out = new OutputStreamWriter(new FileOutputStream(resultTempFile), UTF8);
out.write("\n");
out.write(APACHE_2_LICENSE);
out.write("\n");
for (Map.Entry englishEntry : english.entrySet()) {
String key = englishEntry.getKey();
String value = englishEntry.getValue();
out.write(" ');
String translatedString = translated.get(key);
if (translatedString == null || forceRetranslation.contains(key)) {
anyChange = true;
translatedString = translateString(value, language);
}
out.write(translatedString);
out.write(" \n");
}
out.write(" \n");
out.flush();
} finally {
quietClose(out);
}
if (anyChange) {
System.out.println(" Writing translations");
translatedFile.delete();
resultTempFile.renameTo(translatedFile);
}
}
static String translateString(String english, String language) throws IOException {
if ("en".equals(language)) {
return english;
}
String massagedLanguage = LANGUAGE_CODE_MASSAGINGS.get(language);
if (massagedLanguage != null) {
language = massagedLanguage;
}
System.out.println(" Need translation for " + english);
URL translateURL = new URL(
"https://www.googleapis.com/language/translate/v2?key=" + API_KEY + "&q=" +
URLEncoder.encode(english, "UTF-8") +
"&source=en&target=" + language);
CharSequence translateResult = fetch(translateURL);
Matcher m = TRANSLATE_RESPONSE_PATTERN.matcher(translateResult);
if (!m.find()) {
System.err.println("No translate result");
System.err.println(translateResult);
return english;
}
String translation = m.group(1);
System.out.println(" Got translation " + translation);
// This is a little crude; unescape some common escapes in the raw response
translation = translation.replaceAll("\\\\u0026quot;", "\"");
translation = translation.replaceAll("\\\\u0026#39;", "'");
translation = translation.replaceAll("\\\\u200b", "");
translation = translation.replaceAll(""", "\"");
translation = translation.replaceAll("'", "'");
return translation;
}
private static CharSequence fetch(URL translateURL) throws IOException {
URLConnection connection = translateURL.openConnection();
connection.connect();
StringBuilder translateResult = new StringBuilder(200);
Reader in = null;
try {
in = new InputStreamReader(connection.getInputStream(), UTF8);
char[] buffer = new char[1024];
int charsRead;
while ((charsRead = in.read(buffer)) > 0) {
translateResult.append(buffer, 0, charsRead);
}
} finally {
quietClose(in);
}
return translateResult;
}
private static SortedMap readLines(File file) throws IOException {
SortedMap entries = new TreeMap();
BufferedReader reader = null;
try {
reader = new BufferedReader(new InputStreamReader(new FileInputStream(file), UTF8));
String line;
while ((line = reader.readLine()) != null) {
Matcher m = ENTRY_PATTERN.matcher(line);
if (m.find()) {
String key = m.group(1);
String value = m.group(2);
entries.put(key, value);
}
}
return entries;
} finally {
quietClose(reader);
}
}
private static void quietClose(Closeable closeable) {
if (closeable != null) {
try {
closeable.close();
} catch (IOException ioe) {
// continue
}
}
}
}
© 2015 - 2024 Weber Informatics LLC | Privacy Policy