Java tutorial
/* * Copyright (C) 2012 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.motorola.studio.android.localization.translators; import java.io.IOException; import java.io.UnsupportedEncodingException; import java.net.Authenticator; import java.net.MalformedURLException; import java.net.URL; import java.net.URLEncoder; import java.util.ArrayList; import java.util.Calendar; import java.util.Date; import java.util.HashMap; import java.util.Iterator; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import java.util.regex.Matcher; import java.util.regex.Pattern; import org.apache.commons.httpclient.Credentials; import org.apache.commons.httpclient.DefaultHttpMethodRetryHandler; import org.apache.commons.httpclient.HttpClient; import org.apache.commons.httpclient.HttpException; import org.apache.commons.httpclient.HttpStatus; import org.apache.commons.httpclient.UsernamePasswordCredentials; import org.apache.commons.httpclient.auth.AuthScope; import org.apache.commons.httpclient.methods.GetMethod; import org.apache.commons.httpclient.params.HttpMethodParams; import org.eclipse.core.internal.net.ProxyManager; import org.eclipse.core.net.proxy.IProxyData; import org.eclipse.core.net.proxy.IProxyService; import org.eclipse.core.runtime.IProgressMonitor; import org.eclipse.jface.preference.IPreferenceStore; import org.eclipse.osgi.util.NLS; import org.eclipse.sequoyah.localization.tools.datamodel.node.TranslationResult; import org.eclipse.sequoyah.localization.tools.extensions.classes.ITranslator; import org.eclipse.sequoyah.localization.tools.extensions.implementation.generic.ITranslateDialog; import org.eclipse.swt.SWT; import org.eclipse.swt.events.SelectionAdapter; import org.eclipse.swt.events.SelectionEvent; import org.eclipse.swt.layout.GridData; import org.eclipse.swt.layout.GridLayout; import org.eclipse.swt.widgets.Composite; import org.eclipse.swt.widgets.Link; import com.motorola.studio.android.common.log.StudioLogger; import com.motorola.studio.android.common.proxy.ProxyAuthenticator; import com.motorola.studio.android.common.utilities.EclipseUtils; import com.motorola.studio.android.json.JSONArray; import com.motorola.studio.android.json.JSONObject; import com.motorola.studio.android.json.JSONPair; import com.motorola.studio.android.json.JSONString; import com.motorola.studio.android.json.JSONValue; import com.motorola.studio.android.json.Jason; import com.motorola.studio.android.localization.translators.i18n.TranslateNLS; /** * Uses the Google translator web service (via executing a http request and * parsing the answer) in order to translate a text string. * * Google v2 supports only one source and one destination per request, but support many words. * */ @SuppressWarnings("restriction") public final class GoogleTranslator extends ITranslator implements GoogleTranslatorConstants { /** * Translate all words from some source language to destination language. * This method handles any needed splits in original request due to API limitations. * @param words the words being translated * @param fromLanguage the origin language * @param toLanguage the destination language * @param monitor progress monitor * @return a list of translation results * @throws Exception */ public List<TranslationResult> translate(List<String> words, String fromLanguage, String toLanguage, IProgressMonitor monitor) throws Exception { List<TranslationResult> translationResults = new ArrayList<TranslationResult>(); int characterCount = 0; int MAX_REQUEST_SIZE = getMaxQuerySize(fromLanguage, toLanguage); int maxRequestSize = MAX_REQUEST_SIZE; List<String> wordsToTranslate = new ArrayList<String>(); Iterator<String> wordsIterator = words.iterator(); int counter = 0; while (wordsIterator.hasNext()) { maxRequestSize -= STRING_PAR.length(); String word = wordsIterator.next(); /* try to add some more words to the request. * If there is no more room left to request, execute the translation and continue afterwards */ if (characterCount + word.length() < maxRequestSize) { wordsToTranslate.add(word); characterCount += word.length(); } else { URL translationURL = createTranslationURL(wordsToTranslate, fromLanguage, toLanguage); String httpRequestResponseBody = executeHttpGetRequest(translationURL); List<String> responses = parseTranslationResponse(httpRequestResponseBody); for (int i = 0; i < wordsToTranslate.size(); i++) { translationResults.add(new TranslationResult(words.get(counter++), this, responses.get(i), fromLanguage, toLanguage, Calendar.getInstance().getTime(), true)); } characterCount = 0; maxRequestSize = MAX_REQUEST_SIZE; wordsToTranslate.clear(); wordsToTranslate.add(word); } } /* * execute the request with remaining sentences */ if (!wordsToTranslate.isEmpty()) { URL translationURL = createTranslationURL(wordsToTranslate, fromLanguage, toLanguage); String httpRequestResponseBody = executeHttpGetRequest(translationURL); List<String> responses = parseTranslationResponse(httpRequestResponseBody); for (int i = 0; i < wordsToTranslate.size(); i++) { translationResults.add(new TranslationResult(words.get(counter++), this, responses.get(i), fromLanguage, toLanguage, Calendar.getInstance().getTime(), true)); } } return translationResults; } /** * Translates a string. * * @param text The String to be translated. * @param from Original language. * @param to Target language. * @return The translated String. * @throws Exception on errors. */ @Override public TranslationResult translate(final String text, String from, String to) throws Exception { TranslationResult translationResult; if (text != null && !text.equals("") && text.length() < getMaxQuerySize(from, to)) //$NON-NLS-1$ { String httpResult = ""; //$NON-NLS-1$ URL url = null; // Creates the URL to be used as request try { List<String> sentences = new ArrayList<String>(); sentences.add(text); url = createTranslationURL(sentences, from, to); httpResult = executeHttpGetRequest(url); translationResult = new TranslationResult(text, this, parseTranslationResponse(httpResult).get(0), from, to, Calendar.getInstance().getTime(), true); } catch (UnsupportedEncodingException e) { throw new HttpException(TranslateNLS.GoogleTranslator_Error_UnsupportedEncoding + ENCODING_TYPE); } } else if (text.length() >= getMaxQuerySize(from, to)) { throw new Exception(TranslateNLS.GoogleTranslator_Error_QueryTooBig); } else { translationResult = new TranslationResult(text, this, text, from, to, new Date(), true); } try { String descriptionToLog = StudioLogger.KEY_TRANSLATION_PROVIDER + StudioLogger.VALUE_GOOGLE + StudioLogger.SEPARATOR + StudioLogger.KEY_TRANSLATION_FROM_LANG + from + StudioLogger.SEPARATOR + StudioLogger.KEY_TRANSLATION_TO_LANG + to; StudioLogger.collectUsageData(StudioLogger.WHAT_LOCALIZATION_AUTOMATICTRANSLATION, StudioLogger.KIND_LOCALIZATION, descriptionToLog, TranslationPlugin.PLUGIN_ID, TranslationPlugin.getDefault().getBundle().getVersion().toString()); } catch (Throwable t) { // Do nothing, usage data collection is for statistics and should not prevent tool from work } return translationResult; } /** * Translate a single word from one language to several other * @param sentences sentence being translated * @param fromLanguage source language * @param toLanguages target languages */ @Override public List<TranslationResult> translate(String sentence, String fromLanguage, List<String> toLanguages) throws Exception { List<TranslationResult> translationResults = new ArrayList<TranslationResult>(); // Lets start with some checkings, one can never be too careful if (fromLanguage == null || toLanguages == null || toLanguages.isEmpty()) { // We must have a FROM and a TO languages throw new IllegalArgumentException(TranslateNLS.GoogleTranslator_Error_ToAndFromLanguagesAreEmpty); } else if (sentence == null || sentence.equals("")) //$NON-NLS-1$ { // We must have something to be translated sentence = ""; //$NON-NLS-1$ if (toLanguages.size() == 1) { translationResults.add(new TranslationResult("", this, "", fromLanguage, //$NON-NLS-1$ //$NON-NLS-2$ toLanguages.get(0), new Date(), true)); } } else if (sentence.length() >= getMaxQuerySize(fromLanguage, toLanguages.get(0))) { throw new Exception(TranslateNLS.GoogleTranslator_Error_QueryTooBig); } /* * Delegate the translation to another method */ else { for (String toLanguage : toLanguages) { translationResults.add(translate(sentence, fromLanguage, toLanguage)); } } try { // Collecting usage data for statistic purposes String descriptionToLog = StudioLogger.KEY_TRANSLATION_PROVIDER + StudioLogger.VALUE_GOOGLE + StudioLogger.SEPARATOR + StudioLogger.KEY_TRANSLATION_FROM_LANG + fromLanguage + StudioLogger.SEPARATOR + StudioLogger.KEY_TRANSLATION_TO_LANG + "several languages"; //$NON-NLS-1$ StudioLogger.collectUsageData(StudioLogger.WHAT_LOCALIZATION_AUTOMATICTRANSLATION, StudioLogger.KIND_LOCALIZATION, descriptionToLog, TranslationPlugin.PLUGIN_ID, TranslationPlugin.getDefault().getBundle().getVersion().toString()); } catch (Throwable t) { // Do nothing, usage data collection is for statistics and should not prevent tool from work } return translationResults; } /** * Translate a list of sentences from one language to another * @param sentences sentences being translated * @param fromLanguage source language * @param toLanguage target language * @param monitor progress monitor */ @Override public List<TranslationResult> translateAll(List<String> sentences, String fromLanguage, String toLanguage, IProgressMonitor monitor) throws Exception { // The result (duhh) List<TranslationResult> translationResults = new ArrayList<TranslationResult>(); // Lets start with some checkings, one can never be too carefull if (fromLanguage == null || toLanguage == null) { // We must have a FROM and a TO languages throw new IllegalArgumentException(TranslateNLS.GoogleTranslator_Error_ToAndFromLanguagesAreEmpty); } else if (sentences == null || sentences.size() == 0) { // We must have something to be translated throw new IllegalArgumentException(TranslateNLS.GoogleTranslator_Error_NoAvailableData); } else { translationResults.addAll(translate(sentences, fromLanguage, toLanguage, monitor)); } try { // Collecting usage data for statistic purposes String descriptionToLog = StudioLogger.KEY_TRANSLATION_PROVIDER + StudioLogger.VALUE_GOOGLE + StudioLogger.SEPARATOR + StudioLogger.KEY_TRANSLATION_FROM_LANG + fromLanguage + StudioLogger.SEPARATOR + StudioLogger.KEY_TRANSLATION_TO_LANG + toLanguage; StudioLogger.collectUsageData(StudioLogger.WHAT_LOCALIZATION_AUTOMATICTRANSLATION, StudioLogger.KIND_LOCALIZATION, descriptionToLog, TranslationPlugin.PLUGIN_ID, TranslationPlugin.getDefault().getBundle().getVersion().toString()); } catch (Throwable t) { // Do nothing, usage data collection is for statistics and should not prevent tool from work } return translationResults; } /** * Translates a list of strings from a list of given languages to other given languages (given by a list, or course), * using google Ajax API's for that. * * The three lists have the same number of elements. * * This comment feels like the "Three Swatch watch switching witches watched switched Swatch watch witches switch", * but I'll let it here anyway. */ @Override public List<TranslationResult> translateAll(List<String> words, List<String> fromLanguage, List<String> toLanguage, IProgressMonitor monitor) throws Exception { // The result (duhh) List<TranslationResult> translationResults = new ArrayList<TranslationResult>(); // Lets start with some checkings, one can never be too carefull if (fromLanguage == null || toLanguage == null) { // We must have a FROM and a TO languages throw new IllegalArgumentException(TranslateNLS.GoogleTranslator_Error_ToAndFromLanguagesAreEmpty); } else if (words == null || words.size() == 0) { // We must have something to be translated throw new IllegalArgumentException(TranslateNLS.GoogleTranslator_Error_NoAvailableData); } else { translationResults.addAll(groupAndTranslate(words, fromLanguage, toLanguage, monitor)); } try { // Collecting usage data for statistic purposes String descriptionToLog = StudioLogger.KEY_TRANSLATION_PROVIDER + StudioLogger.VALUE_GOOGLE + StudioLogger.SEPARATOR + StudioLogger.KEY_TRANSLATION_FROM_LANG + fromLanguage + StudioLogger.SEPARATOR + StudioLogger.KEY_TRANSLATION_TO_LANG + toLanguage; StudioLogger.collectUsageData(StudioLogger.WHAT_LOCALIZATION_AUTOMATICTRANSLATION, StudioLogger.KIND_LOCALIZATION, descriptionToLog, TranslationPlugin.PLUGIN_ID, TranslationPlugin.getDefault().getBundle().getVersion().toString()); } catch (Throwable t) { // Do nothing, usage data collection is for statistics and should not prevent tool from work } return translationResults; } private List<TranslationResult> groupAndTranslate(List<String> words, List<String> fromLanguage, List<String> toLanguage, IProgressMonitor monitor) throws Exception { List<TranslationResult> results = new ArrayList<TranslationResult>(); /* * Get all words with same source and same destination and group them to make translation more efficient * Notice that this implementation relies on input condition that all lists have the same size and all elements with same index makes one request */ class StringItem { private String sentence = ""; private int orderNumber = -1; public StringItem(String sentence, int orderNumber) { this.sentence = sentence; this.orderNumber = orderNumber; } public Integer getOrderNumber() { return orderNumber; } public String getSentence() { return sentence; } @Override public String toString() { return orderNumber + "|" + sentence; } } /* * This map holds a list of group of stringitems being translated. These items have the same from and to languages * Using linkedHashMap to keep insertionOrder */ Map<String, List<StringItem>> sameSourceDestMap = new LinkedHashMap<String, List<StringItem>>(); Map<Integer, TranslationResult> translations = new HashMap<Integer, TranslationResult>(); // group things with same from and to languages for (int i = 0; i < words.size(); i++) { /* * Check if one of the words are big enough to not be translated */ if (words.get(i).length() >= getMaxQuerySize(fromLanguage.get(i), toLanguage.get(i)) - STRING_PAR.length() - 1) { throw new Exception(TranslateNLS.GoogleTranslator_Error_QueryTooBig); } String key = fromLanguage.get(i) + "|" + toLanguage.get(i); List<StringItem> itemsToTranslate = sameSourceDestMap.get(key); if (itemsToTranslate == null) { itemsToTranslate = new ArrayList<StringItem>(); sameSourceDestMap.put(key, itemsToTranslate); } itemsToTranslate.add(new StringItem(words.get(i), i)); } for (String key : sameSourceDestMap.keySet()) { List<StringItem> itemsToTranslate = sameSourceDestMap.get(key); List<String> items = new ArrayList<String>(); for (StringItem item : itemsToTranslate) { items.add(item.getSentence()); } List<TranslationResult> tempResults = translate(items, key.split("\\|")[0], key.split("\\|")[1], monitor); for (int i = 0; i < itemsToTranslate.size(); i++) { translations.put(itemsToTranslate.get(i).getOrderNumber(), tempResults.get(i)); } } for (int i = 0; i < words.size(); i++) { results.add(translations.get(i)); } return results; } private int getMaxQuerySize(String fromLanguage, String toLanguage) { return MAX_QUERY_SIZE - TRANSLATE_URL_WITHOUT_PARAMS.length() - API_KEY_PARAM.length() - getApiKey().length() - SOURCE_PAR.length() - fromLanguage.length() - TARGET_PARAM.length() - toLanguage.length(); } /** * Parse the translation response of the http request * @param httpRequestResponseBody the response body * @param sourceLanguage the source language * @param destinationLanguage the destination language * @return a list of String objects for the strings translated for source/destination languages pair */ private List<String> parseTranslationResponse(String httpRequestResponseBody) { JSONPair translationSection = getTranslationSection(httpRequestResponseBody); return getTranslations(translationSection); } /* * { "data": { "translations": [ { "translatedText": "bla bla bla" }, { "translatedText": "foo bar" } ] } } */ private JSONPair getTranslationSection(String httpRequestResponseBody) { Jason ripper = new Jason(httpRequestResponseBody); JSONPair translationsSection = null; Iterator<JSONObject> jsonIterator = ripper.getJSON().iterator(); while (translationsSection == null && jsonIterator.hasNext()) { translationsSection = findPair(jsonIterator.next(), TRANSLATIONS_SECTION); } return translationsSection; } private static JSONPair findPair(JSONValue origin, String name) { JSONPair pair = null; if (origin instanceof JSONObject) { JSONObject object = (JSONObject) origin; Iterator<JSONPair> pairs = object.getValue().iterator(); while (pair == null && pairs.hasNext()) { JSONPair jsonPair = pairs.next(); if (jsonPair.getName().equals(name)) { pair = jsonPair; } else { pair = findPair(jsonPair.getValue(), name); } } } return pair; } private List<String> getTranslations(JSONPair translationSection) { List<String> translations = new ArrayList<String>(); if (translationSection.getValue() instanceof JSONArray) { JSONArray translationsArray = (JSONArray) translationSection.getValue(); for (JSONValue translationObject : translationsArray.getValue()) { translations.add(getTranslation(translationObject)); } } return translations; } /** * @param translationObject * { * "translatedText": "Hallo Welt" * } * @return pure translation * Hallo Welt */ private String getTranslation(JSONValue translationObject) { String translation = null; if (translationObject instanceof JSONObject) { JSONObject jsonObject = (JSONObject) translationObject; translation = ((JSONString) jsonObject.getValue().iterator().next().getValue()).getValue(); } return translation != null ? fixHTMLTags(translation) : null; } private URL createTranslationURL(List<String> wordsToTranslate, String fromLanguage, String toLanguage) throws UnsupportedEncodingException { URL translationURL = null; // We need to unescape the ' (apostrophe) before sending it to translation String regex = "\\\\'"; //$NON-NLS-1$ Pattern pattern = Pattern.compile(regex); StringBuilder urlBuilder = new StringBuilder(TRANSLATE_URL_WITHOUT_PARAMS); urlBuilder.append(URL_PARAMETERS.replace("#FROM#", fromLanguage).replace("#TO#", toLanguage) .replace("#API_KEY#", getApiKey())); for (String word : wordsToTranslate) { String wordToTranslate = pattern.matcher(word).replaceAll("'"); urlBuilder.append(STRING_PAR); urlBuilder.append(URLEncoder.encode(wordToTranslate, ENCODING_TYPE)); } try { translationURL = new URL(urlBuilder.toString()); } catch (MalformedURLException e) { StudioLogger.error(getClass(), "Unable to create translation URL", e); } return translationURL; } /** * The Android localization files text must accept three HTML tags: i, b and u. * Nevertheless, google translator returns the close part of this tags with * a extra-space that makes the sintax wrong. This method will try to fix it. * @param originalText * @return the text with the tags fixed */ private static String fixHTMLTags(String originalText) { String result = ""; //$NON-NLS-1$ if (originalText != null) { result = originalText; } result = originalText.replaceAll("</ b>", "</b>"); //$NON-NLS-1$ //$NON-NLS-2$ result = originalText.replaceAll("</ i>", "</i>"); //$NON-NLS-1$ //$NON-NLS-2$ result = originalText.replaceAll("</ u>", "</u>"); //$NON-NLS-1$ //$NON-NLS-2$ result = originalText.replaceAll("</ B>", "</B>"); //$NON-NLS-1$ //$NON-NLS-2$ result = originalText.replaceAll("</ I>", "</I>"); //$NON-NLS-1$ //$NON-NLS-2$ result = originalText.replaceAll("</ U>", "</U>"); //$NON-NLS-1$ //$NON-NLS-2$ result = originalText.replaceAll(" \\\\ n ", " \\\\n "); //$NON-NLS-1$ //$NON-NLS-2$ return result; } /** * Creates an HTTP request with the URL, execute it as a get, and returns * the a string with the result. * * @param url * URL to be executed. * @return String with the URL execution result. * @throws IOException * If an exception occurs on transport * @throws HttpException * If an exception occurs on the protocol * @throws Exception * on error. */ protected static String executeHttpGetRequest(final URL url) throws HttpException { // Checking query size due to google policies if (url.toString().length() > MAX_QUERY_SIZE) { throw new HttpException(TranslateNLS.GoogleTranslator_Error_QueryTooBig); } // Try to retrieve proxy configuration to use if necessary IProxyService proxyService = ProxyManager.getProxyManager(); IProxyData proxyData = null; if (proxyService.isProxiesEnabled() || proxyService.isSystemProxiesEnabled()) { Authenticator.setDefault(new ProxyAuthenticator()); String urlStr = url.toString(); if (urlStr.startsWith("https")) { proxyData = proxyService.getProxyData(IProxyData.HTTPS_PROXY_TYPE); StudioLogger.debug(GoogleTranslator.class, "Using https proxy"); //$NON-NLS-1$ } else if (urlStr.startsWith("http")) { proxyData = proxyService.getProxyData(IProxyData.HTTP_PROXY_TYPE); StudioLogger.debug(GoogleTranslator.class, "Using http proxy"); //$NON-NLS-1$ } else { StudioLogger.debug(GoogleTranslator.class, "Not using any proxy"); //$NON-NLS-1$ } } // Creates the http client and the method to be executed HttpClient client = null; client = new HttpClient(); // If there is proxy data, work with it if (proxyData != null) { if (proxyData.getHost() != null) { // Sets proxy host and port, if any client.getHostConfiguration().setProxy(proxyData.getHost(), proxyData.getPort()); } if (proxyData.getUserId() != null && proxyData.getUserId().trim().length() > 0) { // Sets proxy user and password, if any Credentials cred = new UsernamePasswordCredentials(proxyData.getUserId(), proxyData.getPassword() == null ? "" : proxyData.getPassword()); //$NON-NLS-1$ client.getState().setProxyCredentials(AuthScope.ANY, cred); } } // Creating the method to be executed, the URL at this point is enough // because it is complete GetMethod method = new GetMethod(url.toString()); // Set method to be retried three times in case of error method.getParams().setParameter(HttpMethodParams.RETRY_HANDLER, new DefaultHttpMethodRetryHandler(RETRIES, false)); method.setRequestHeader(REFERER_HEADER, REFERER_SITE); // Set the connection timeout client.getHttpConnectionManager().getParams().setConnectionTimeout(new Integer(TIMEOUT)); String result = ""; //$NON-NLS-1$ try { // Execute the method. int statusCode; try { statusCode = client.executeMethod(method); result = method.getResponseBodyAsString(MAX_SIZE); } catch (IOException e) { throw new HttpException(TranslateNLS.GoogleTranslator_Error_CannotConnectToServer + e.getMessage()); } checkStatusCode(statusCode, result); // Unescape any possible unicode char result = unescapeUnicode(result); // Unescape any possible HTML sequence result = unescapeHTML(result); } finally { // Release the connection. method.releaseConnection(); } return result; } private static void checkStatusCode(int statusCode, String response) throws HttpException { switch (statusCode) { case HttpStatus.SC_OK: //do nothing break; case HttpStatus.SC_BAD_REQUEST: throw new HttpException(NLS.bind(TranslateNLS.GoogleTranslator_ErrorMessageExecutingRequest, getErrorMessage(response))); case HttpStatus.SC_REQUEST_URI_TOO_LONG: throw new HttpException(TranslateNLS.GoogleTranslator_Error_QueryTooBig); case HttpStatus.SC_FORBIDDEN: throw new HttpException(NLS.bind(TranslateNLS.GoogleTranslator_ErrorMessageNoValidTranslationReturned, getErrorMessage(response))); default: throw new HttpException(NLS.bind(TranslateNLS.GoogleTranslator_Error_HTTPRequestError, new Object[] { statusCode, getErrorMessage(response) })); } } /** * According to APIv2, the error message is in the end of the response * { "error": { "errors": [ { "domain": "global", "reason": "invalid", "message": "Invalid Value" } ], "code": 400, "message": "Invalid Value" } } * @param response the method response body * @return the error message */ private static String getErrorMessage(String response) { Jason ripper = new Jason(response); JSONPair translationsSection = null; Iterator<JSONObject> jsonIterator = ripper.getJSON().iterator(); while (translationsSection == null && jsonIterator.hasNext()) { translationsSection = findPair(jsonIterator.next(), MESSAGE_TEXT); } return translationsSection != null ? ((JSONString) translationsSection.getValue()).getValue() : null; } /** * Unescape any HTML sequence that exists inside the string. For example, * the sequence ' will be changed to the ' symbol * * @param source * original text * @return the result */ private static String unescapeHTML(String source) { Pattern p = Pattern.compile("&#([0-9]+);"); //$NON-NLS-1$ String result = source; Matcher m = p.matcher(result); while (m.find()) { char c = (char) Integer.parseInt(m.group(1)); if (c == "'".charAt(0)) //$NON-NLS-1$ { // Apostrophes must be escaped by preceding it with a backslash (\) on the XML file result = result.replaceAll(m.group(0), "\\\\'"); //$NON-NLS-1$ } else { result = result.replaceAll(m.group(0), "" + c); //$NON-NLS-1$ } } return result; } /** * Unescape any Unicode sequence that exists inside the string. * * For example, the sequence \u0000 will be changed to the symbol * correnponded to the 0000 unicode value. * * @param source * original text * @return the result */ private static String unescapeUnicode(String source) { int i = 0, len = source.length(); char c; StringBuffer buffer = new StringBuffer(len); while (i < len) { c = source.charAt(i++); if (c == '\\') { if (i < len) { c = source.charAt(i++); if (c == 'u') { c = (char) Integer.parseInt(source.substring(i, i + 4), 16); i += 4; } } } buffer.append(c); } return buffer.toString(); } private static String getApiKey() { String apiKey = GoogleTranslatorConstants.API_KEY; IPreferenceStore prefStore = TranslationPlugin.getDefault().getPreferenceStore(); if (!prefStore.isDefault(GoogleTranslatorConstants.API_KEY_VALUE_PREFERENCE)) { apiKey = prefStore.getString(GoogleTranslatorConstants.API_KEY_VALUE_PREFERENCE); if (apiKey == null) { apiKey = GoogleTranslatorConstants.API_KEY; } } return apiKey; } @Override public Composite createCustomArea(Composite parent, final ITranslateDialog dialog) { Composite mainComposite = new Composite(parent, SWT.NONE); mainComposite.setLayout(new GridLayout(1, false)); final Link prefPageLink = new Link(mainComposite, SWT.NONE); prefPageLink.setText(TranslateNLS.GoogleTranslator_ChangeAPIkeyLabel); prefPageLink.setLayoutData(new GridData(SWT.RIGHT, SWT.CENTER, true, true, 1, 1)); prefPageLink.addSelectionListener(new SelectionAdapter() { @Override public void widgetSelected(SelectionEvent e) { EclipseUtils.openPreference(prefPageLink.getShell(), "com.motorola.studio.android.localization.translators.preferencepage"); //$NON-NLS-1$ dialog.validate(); } }); mainComposite.setLayoutData(new GridData(SWT.RIGHT, SWT.BOTTOM, false, false)); return mainComposite; } @Override public String canTranslate(String fromLanguage, String[] toLanguages) { return getApiKey() == null || GoogleTranslatorConstants.API_KEY.equals(getApiKey()) ? TranslateNLS.GoogleTranslator_ErrorNoAPIkeySet : null; } }