Singularity-Viewer/SingularityViewer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

This works for now. Need to do more testing.

Browse Source
This commit is contained in:
Drake Arconis
2012-02-19 19:43:53 -05:00
parent 665569dfc7
commit c6d6eed7d3
4 changed files with 696 additions and 225 deletions
Download Patch File Download Diff File Expand all files Collapse all files

54
indra/newview/app_settings/settings.xml
View File

@@ -1,16 +1,15 @@
<?xml version="1.0"?> <?xml version="1.0"?>
<llsd> <llsd>
<map> <map>
<key>Include</key> <key>Include</key>
<array> <array>
<string>settings_ascent.xml</string> <string>settings_ascent.xml</string>
<string>settings_ascent_coa.xml</string> <string>settings_ascent_coa.xml</string>
<string>settings_sh.xml</string> <string>settings_sh.xml</string>
<string>settings_rlv.xml</string> <string>settings_rlv.xml</string>
</array> </array>
<key>SianaRenderDeferredInvisiprim</key>
<key>SianaRenderDeferredInvisiprim</key> <map>
<map>
<key>Comment</key> <key>Comment</key>
<string>Support invisiprims in deferred mode</string> <string>Support invisiprims in deferred mode</string>
<key>Persist</key> <key>Persist</key>
@@ -7525,12 +7524,45 @@
<key>Comment</key> <key>Comment</key>
<string>Translate incoming chat messages</string> <string>Translate incoming chat messages</string>
<key>Persist</key> <key>Persist</key>
<integer>0</integer> <integer>1</integer>
<key>Type</key> <key>Type</key>
<string>Boolean</string> <string>Boolean</string>
<key>Value</key> <key>Value</key>
<integer>0</integer> <integer>0</integer>
</map> </map>
<key>TranslationService</key>
<map>
<key>Comment</key>
<string>Translation API to use. (google|bing)</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>String</string>
<key>Value</key>
<string>bing</string>
</map>
<key>GoogleTranslateAPIKey</key>
<map>
<key>Comment</key>
<string>Google Translate API key</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>String</string>
<key>Value</key>
<string></string>
</map>
<key>BingTranslateAPIKey</key>
<map>
<key>Comment</key>
<string>Bing AppID to use with the Microsoft Translator API</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>String</string>
<key>Value</key>
<string></string>
</map>
<key>LastFeatureVersion</key> <key>LastFeatureVersion</key>
<map> <map>
<key>Comment</key> <key>Comment</key>

469
indra/newview/lltranslate.cpp
View File

@@ -2,136 +2,401 @@
* @file lltranslate.cpp * @file lltranslate.cpp
* @brief Functions for translating text via Google Translate. * @brief Functions for translating text via Google Translate.
* *
* $LicenseInfo:firstyear=2009&license=viewergpl$ * $LicenseInfo:firstyear=2009&license=viewerlgpl$
* * Second Life Viewer Source Code
* Copyright (c) 2009, Linden Research, Inc. * Copyright (C) 2010, Linden Research, Inc.
* *
* Second Life Viewer Source Code * This library is free software; you can redistribute it and/or
* The source code in this file ("Source Code") is provided by Linden Lab * modify it under the terms of the GNU Lesser General Public
* to you under the terms of the GNU General Public License, version 2.0 * License as published by the Free Software Foundation;
* ("GPL"), unless you have obtained a separate licensing agreement * version 2.1 of the License only.
* ("Other License"), formally executed by you and Linden Lab. Terms of *
* the GPL can be found in doc/GPL-license.txt in this distribution, or * This library is distributed in the hope that it will be useful,
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2 * but WITHOUT ANY WARRANTY; without even the implied warranty of
* * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* There are special exceptions to the terms and conditions of the GPL as * Lesser General Public License for more details.
* it is applied to this Source Code. View the full text of the exception *
* in the file doc/FLOSS-exception.txt in this software distribution, or * You should have received a copy of the GNU Lesser General Public
* online at * License along with this library; if not, write to the Free Software
* http://secondlifegrid.net/programs/open_source/licensing/flossexception * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
* *
* By copying, modifying or distributing this software, you acknowledge * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA
* that you have read and understood your obligations described above, * $/LicenseInfo$
* and agree to abide by those obligations. */
*
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
* COMPLETENESS OR PERFORMANCE.
* $/LicenseInfo$
*/
#include "llviewerprecompiledheaders.h" #include "llviewerprecompiledheaders.h"
#include "llbufferstream.h"
#include "lltranslate.h" #include "lltranslate.h"
#include <curl/curl.h>
#include "llbufferstream.h"
#include "lltrans.h"
#include "llui.h" #include "llui.h"
#include "sgversion.h" #include "llviewercontrol.h"
#include "llweb.h" #include "llweb.h"
// <edit> #include "sgversion.h"
#include "llviewercontrol.h"
// </edit>
// These two are concatenated with the language specifiers to form a complete Google Translate URL #include "jsoncpp/reader.h"
const char* LLTranslate::m_GoogleURL = "http://ajax.googleapis.com/ajax/services/language/translate?v=1.0&q=";
const char* LLTranslate::m_GoogleLangSpec = "&langpair=";
float LLTranslate::m_GoogleTimeout = 10;
LLSD LLTranslate::m_Header; // virtual
// These constants are for the GET header. void LLGoogleTranslationHandler::getTranslateURL(
const char* LLTranslate::m_AcceptHeader = "Accept"; std::string &url,
const char* LLTranslate::m_AcceptType = "text/plain"; const std::string &from_lang,
const char* LLTranslate::m_AgentHeader = "User-Agent"; const std::string &to_lang,
const std::string &text) const
// These constants are in the JSON returned from Google
const char* LLTranslate::m_GoogleData = "responseData";
const char* LLTranslate::m_GoogleTranslation = "translatedText";
const char* LLTranslate::m_GoogleLanguage = "detectedSourceLanguage";
//static
void LLTranslate::translateMessage(LLHTTPClient::ResponderPtr &result, const std::string &fromLang, const std::string &toLang, const std::string &mesg)
{ {
std::string url; url = std::string("https://www.googleapis.com/language/translate/v2?key=")
getTranslateUrl(url, fromLang, toLang, mesg); + getAPIKey() + "&q=" + LLURI::escape(text) + "&target=" + to_lang;
if (!from_lang.empty())
//<edit>
std::string user_agent = gCurrentVersion;
//</edit>
if (!m_Header.size())
{ {
m_Header.insert(m_AcceptHeader, LLSD(m_AcceptType)); url += "&source=" + from_lang;
m_Header.insert(m_AgentHeader, LLSD(user_agent));
}
LLHTTPClient::get(url, result, m_Header, m_GoogleTimeout);
}
//static
void LLTranslate::getTranslateUrl(std::string &translateUrl, const std::string &fromLang, const std::string &toLang, const std::string &mesg)
{
std::string escaped_mesg = LLWeb::curlEscape(mesg);
translateUrl = m_GoogleURL
+ escaped_mesg + m_GoogleLangSpec
+ fromLang // 'from' language; empty string for auto
+ "%7C" // |
+ toLang; // 'to' language
}
//static
void LLTranslate::stringReplaceAll(std::string& context, const std::string& from, const std::string& to)
{
size_t lookHere = 0;
size_t foundHere;
while((foundHere = context.find(from, lookHere))
!= std::string::npos) {
context.replace(foundHere, from.size(), to);
lookHere = foundHere + to.size();
} }
} }
//static // virtual
BOOL LLTranslate::parseGoogleTranslate(const std::string result, std::string &translation, std::string &detectedLanguage) void LLGoogleTranslationHandler::getKeyVerificationURL(
std::string& url,
const std::string& key) const
{
url = std::string("https://www.googleapis.com/language/translate/v2/languages?key=")
+ key + "&target=en";
}
// virtual
bool LLGoogleTranslationHandler::parseResponse(
int& status,
const std::string& body,
std::string& translation,
std::string& detected_lang,
std::string& err_msg) const
{ {
Json::Value root; Json::Value root;
Json::Reader reader; Json::Reader reader;
BOOL parsingSuccessful = reader.parse(result, root );
if ( !parsingSuccessful ) if (!reader.parse(body, root))
{ {
LL_WARNS("JSON") << reader.getFormatedErrorMessages() << LL_ENDL; err_msg = reader.getFormatedErrorMessages();
return FALSE; return false;
} }
translation = root[m_GoogleData].get(m_GoogleTranslation, "").asString(); if (!root.isObject()) // empty response? should not happen
detectedLanguage = root[m_GoogleData].get(m_GoogleLanguage, "").asString(); {
return TRUE; return false;
}
if (status != STATUS_OK)
{
// Request failed. Extract error message from the response.
parseErrorResponse(root, status, err_msg);
return false;
}
// Request succeeded, extract translation from the response.
return parseTranslation(root, translation, detected_lang);
}
// virtual
bool LLGoogleTranslationHandler::isConfigured() const
{
return !getAPIKey().empty();
}
// static
void LLGoogleTranslationHandler::parseErrorResponse(
const Json::Value& root,
int& status,
std::string& err_msg)
{
const Json::Value& error = root.get("error", 0);
if (!error.isObject() || !error.isMember("message") || !error.isMember("code"))
{
return;
}
err_msg = error["message"].asString();
status = error["code"].asInt();
}
// static
bool LLGoogleTranslationHandler::parseTranslation(
const Json::Value& root,
std::string& translation,
std::string& detected_lang)
{
// JsonCpp is prone to aborting the program on failed assertions,
// so be super-careful and verify the response format.
const Json::Value& data = root.get("data", 0);
if (!data.isObject() || !data.isMember("translations"))
{
return false;
}
const Json::Value& translations = data["translations"];
if (!translations.isArray() || translations.size() == 0)
{
return false;
}
const Json::Value& first = translations[0U];
if (!first.isObject() || !first.isMember("translatedText"))
{
return false;
}
translation = first["translatedText"].asString();
detected_lang = first.get("detectedSourceLanguage", "").asString();
return true;
}
// static
std::string LLGoogleTranslationHandler::getAPIKey()
{
return gSavedSettings.getString("GoogleTranslateAPIKey");
}
// virtual
void LLBingTranslationHandler::getTranslateURL(
std::string &url,
const std::string &from_lang,
const std::string &to_lang,
const std::string &text) const
{
url = std::string("http://api.microsofttranslator.com/v2/Http.svc/Translate?appId=")
+ getAPIKey() + "&text=" + LLURI::escape(text) + "&to=" + to_lang;
if (!from_lang.empty())
{
url += "&from=" + from_lang;
}
}
// virtual
void LLBingTranslationHandler::getKeyVerificationURL(
std::string& url,
const std::string& key) const
{
url = std::string("http://api.microsofttranslator.com/v2/Http.svc/GetLanguagesForTranslate?appId=")
+ key;
}
// virtual
bool LLBingTranslationHandler::parseResponse(
int& status,
const std::string& body,
std::string& translation,
std::string& detected_lang,
std::string& err_msg) const
{
if (status != STATUS_OK)
{
static const std::string MSG_BEGIN_MARKER = "Message: ";
size_t begin = body.find(MSG_BEGIN_MARKER);
if (begin != std::string::npos)
{
begin += MSG_BEGIN_MARKER.size();
}
else
{
begin = 0;
err_msg.clear();
}
size_t end = body.find("</p>", begin);
err_msg = body.substr(begin, end-begin);
LLStringUtil::replaceString(err_msg, "&#xD;", ""); // strip CR
return false;
}
// Sample response: <string xmlns="http://schemas.microsoft.com/2003/10/Serialization/">Hola</string>
size_t begin = body.find(">");
if (begin == std::string::npos || begin >= (body.size() - 1))
{
begin = 0;
}
else
{
++begin;
}
size_t end = body.find("</string>", begin);
detected_lang = ""; // unsupported by this API
translation = body.substr(begin, end-begin);
LLStringUtil::replaceString(translation, "&#xD;", ""); // strip CR
return true;
}
// virtual
bool LLBingTranslationHandler::isConfigured() const
{
return !getAPIKey().empty();
}
// static
std::string LLBingTranslationHandler::getAPIKey()
{
return gSavedSettings.getString("BingTranslateAPIKey");
}
LLTranslate::TranslationReceiver::TranslationReceiver(const std::string& from_lang, const std::string& to_lang)
: mFromLang(from_lang)
, mToLang(to_lang)
, mHandler(LLTranslate::getPreferredHandler())
{
}
// virtual
void LLTranslate::TranslationReceiver::completedRaw(
U32 http_status,
const std::string& reason,
const LLChannelDescriptors& channels,
const LLIOPipe::buffer_ptr_t& buffer)
{
LLBufferStream istr(channels, buffer.get());
std::stringstream strstrm;
strstrm << istr.rdbuf();
const std::string body = strstrm.str();
std::string translation, detected_lang, err_msg;
int status = http_status;
LL_DEBUGS("Translate") << "HTTP status: " << status << " " << reason << LL_ENDL;
LL_DEBUGS("Translate") << "Response body: " << body << LL_ENDL;
if (mHandler.parseResponse(status, body, translation, detected_lang, err_msg))
{
// Fix up the response
LLStringUtil::replaceString(translation, "&lt;", "<");
LLStringUtil::replaceString(translation, "&gt;",">");
LLStringUtil::replaceString(translation, "&quot;","\"");
LLStringUtil::replaceString(translation, "&#39;","'");
LLStringUtil::replaceString(translation, "&amp;","&");
LLStringUtil::replaceString(translation, "&apos;","'");
handleResponse(translation, detected_lang);
}
else
{
if (err_msg.empty())
{
err_msg = LLTrans::getString("TranslationResponseParseError");
}
llwarns << "Translation request failed: " << err_msg << llendl;
handleFailure(status, err_msg);
}
}
LLTranslate::KeyVerificationReceiver::KeyVerificationReceiver(EService service)
: mService(service)
{
}
LLTranslate::EService LLTranslate::KeyVerificationReceiver::getService() const
{
return mService;
}
// virtual
void LLTranslate::KeyVerificationReceiver::completedRaw(
U32 http_status,
const std::string& reason,
const LLChannelDescriptors& channels,
const LLIOPipe::buffer_ptr_t& buffer)
{
bool ok = (http_status == 200);
setVerificationStatus(ok);
}
//static
void LLTranslate::translateMessage(
TranslationReceiverPtr &receiver,
const std::string &from_lang,
const std::string &to_lang,
const std::string &mesg)
{
std::string url;
receiver->mHandler.getTranslateURL(url, from_lang, to_lang, mesg);
LL_DEBUGS("Translate") << "Sending translation request: " << url << LL_ENDL;
sendRequest(url, receiver);
}
// static
void LLTranslate::verifyKey(
KeyVerificationReceiverPtr& receiver,
const std::string& key)
{
std::string url;
const LLTranslationAPIHandler& handler = getHandler(receiver->getService());
handler.getKeyVerificationURL(url, key);
LL_DEBUGS("Translate") << "Sending key verification request: " << url << LL_ENDL;
sendRequest(url, receiver);
} }
//static //static
std::string LLTranslate::getTranslateLanguage() std::string LLTranslate::getTranslateLanguage()
{ {
std::string language = "en"; std::string language = gSavedSettings.getString("TranslateLanguage");
if (LLUI::sConfigGroup) if (language.empty() || language == "default")
{ {
language = LLUI::sConfigGroup->getString("TranslateLanguage"); language = LLUI::getLanguage();
if (language.empty() || language == "default")
{
language = LLUI::getLanguage();
}
} }
language = language.substr(0,2); language = language.substr(0,2);
return language; return language;
} }
// static
bool LLTranslate::isTranslationConfigured()
{
return getPreferredHandler().isConfigured();
}
// static
const LLTranslationAPIHandler& LLTranslate::getPreferredHandler()
{
EService service = SERVICE_BING;
std::string service_str = gSavedSettings.getString("TranslationService");
if (service_str == "google")
{
service = SERVICE_GOOGLE;
}
return getHandler(service);
}
// static
const LLTranslationAPIHandler& LLTranslate::getHandler(EService service)
{
static LLGoogleTranslationHandler google;
static LLBingTranslationHandler bing;
if (service == SERVICE_GOOGLE)
{
return google;
}
return bing;
}
// static
void LLTranslate::sendRequest(const std::string& url, LLHTTPClient::ResponderPtr responder)
{
static const float REQUEST_TIMEOUT = 5;
static LLSD sHeader;
if (!sHeader.size())
{
std::string user_agent = llformat("%s %d.%d.%d (%d)",
gVersionChannel,
gVersionMajor,
gVersionMinor,
gVersionPatch,
gVersionBuild);
sHeader.insert("Accept", "text/plain");
sHeader.insert("User-Agent", user_agent);
}
LLHTTPClient::get(url, responder, sHeader, REQUEST_TIMEOUT);
}

372
indra/newview/lltranslate.h
View File

@@ -2,33 +2,27 @@
* @file lltranslate.h * @file lltranslate.h
* @brief Human language translation class and JSON response receiver. * @brief Human language translation class and JSON response receiver.
* *
* $LicenseInfo:firstyear=2009&license=viewergpl$ * $LicenseInfo:firstyear=2009&license=viewerlgpl$
* * Second Life Viewer Source Code
* Copyright (c) 2009, Linden Research, Inc. * Copyright (C) 2010, Linden Research, Inc.
* *
* Second Life Viewer Source Code * This library is free software; you can redistribute it and/or
* The source code in this file ("Source Code") is provided by Linden Lab * modify it under the terms of the GNU Lesser General Public
* to you under the terms of the GNU General Public License, version 2.0 * License as published by the Free Software Foundation;
* ("GPL"), unless you have obtained a separate licensing agreement * version 2.1 of the License only.
* ("Other License"), formally executed by you and Linden Lab. Terms of *
* the GPL can be found in doc/GPL-license.txt in this distribution, or * This library is distributed in the hope that it will be useful,
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2 * but WITHOUT ANY WARRANTY; without even the implied warranty of
* * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* There are special exceptions to the terms and conditions of the GPL as * Lesser General Public License for more details.
* it is applied to this Source Code. View the full text of the exception *
* in the file doc/FLOSS-exception.txt in this software distribution, or * You should have received a copy of the GNU Lesser General Public
* online at * License along with this library; if not, write to the Free Software
* http://secondlifegrid.net/programs/open_source/licensing/flossexception * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
* *
* By copying, modifying or distributing this software, you acknowledge * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA
* that you have read and understood your obligations described above, * $/LicenseInfo$
* and agree to abide by those obligations. */
*
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
* COMPLETENESS OR PERFORMANCE.
* $/LicenseInfo$
*/
#ifndef LL_LLTRANSLATE_H #ifndef LL_LLTRANSLATE_H
#define LL_LLTRANSLATE_H #define LL_LLTRANSLATE_H
@@ -37,89 +31,273 @@
#include "llbufferstream.h" #include "llbufferstream.h"
#include "jsoncpp/reader.h" #include "jsoncpp/reader.h"
class LLTranslate namespace Json
{ {
public : class Value;
class TranslationReceiver: public LLHTTPClient::Responder }
{
protected:
TranslationReceiver(const std::string &fromLang, const std::string &toLang)
: m_fromLang(fromLang),
m_toLang(toLang)
{
}
virtual void handleResponse(const std::string &translation, const std::string &recognizedLang) {} /**
virtual void handleFailure() {}; * Handler of an HTTP machine translation service.
*
* Derived classes know the service URL
* and how to parse the translation result.
*/
class LLTranslationAPIHandler
{
public:
/**
* Get URL for translation of the given string.
*
* Sending HTTP GET request to the URL will initiate translation.
*
* @param[out] url Place holder for the result.
* @param from_lang Source language. Leave empty for auto-detection.
* @param to_lang Target language.
* @param text Text to translate.
*/
virtual void getTranslateURL(
std::string &url,
const std::string &from_lang,
const std::string &to_lang,
const std::string &text) const = 0;
public: /**
~TranslationReceiver() * Get URL to verify the given API key.
{ *
} * Sending request to the URL verifies the key.
* Positive HTTP response (code 200) means that the key is valid.
*
* @param[out] url Place holder for the URL.
* @param[in] key Key to verify.
*/
virtual void getKeyVerificationURL(
std::string &url,
const std::string &key) const = 0;
virtual void error(U32 status, const std::string& reason) /**
{ * Parse translation response.
LL_WARNS("Translate") << "URL Request error: " << reason << LL_ENDL; *
handleFailure(); * @param[in,out] status HTTP status. May be modified while parsing.
} * @param body Response text.
* @param[out] translation Translated text.
* @param[out] detected_lang Detected source language. May be empty.
* @param[out] err_msg Error message (in case of error).
*/
virtual bool parseResponse(
int& status,
const std::string& body,
std::string& translation,
std::string& detected_lang,
std::string& err_msg) const = 0;
virtual void completedRaw( /**
U32 status, * @return if the handler is configured to function properly
const std::string& reason, */
const LLChannelDescriptors& channels, virtual bool isConfigured() const = 0;
const LLIOPipe::buffer_ptr_t& buffer)
{
LLBufferStream istr(channels, buffer.get());
std::stringstream strstrm; virtual ~LLTranslationAPIHandler() {}
strstrm << istr.rdbuf();
const std::string result = strstrm.str();
std::string translation; protected:
std::string detectedLanguage; static const int STATUS_OK = 200;
};
if (!parseGoogleTranslate(result, translation, detectedLanguage)) /// Google Translate v2 API handler.
{ class LLGoogleTranslationHandler : public LLTranslationAPIHandler
handleFailure(); {
return; LOG_CLASS(LLGoogleTranslationHandler);
}
// Fix up the response public:
stringReplaceAll( translation, "&lt;","<"); /*virtual*/ void getTranslateURL(
stringReplaceAll( translation, "&gt;",">"); std::string &url,
stringReplaceAll( translation, "&quot;","\""); const std::string &from_lang,
stringReplaceAll( translation, "&#39;","'"); const std::string &to_lang,
stringReplaceAll( translation, "&amp;","&"); const std::string &text) const;
stringReplaceAll( translation, "&apos;","'"); /*virtual*/ void getKeyVerificationURL(
std::string &url,
handleResponse(translation, detectedLanguage); const std::string &key) const;
} /*virtual*/ bool parseResponse(
int& status,
protected: const std::string& body,
const std::string m_toLang; std::string& translation,
const std::string m_fromLang; std::string& detected_lang,
}; std::string& err_msg) const;
/*virtual*/ bool isConfigured() const;
static void translateMessage(LLHTTPClient::ResponderPtr &result, const std::string &fromLang, const std::string &toLang, const std::string &mesg);
static float m_GoogleTimeout;
static std::string getTranslateLanguage();
private: private:
static void getTranslateUrl(std::string &translateUrl, const std::string &fromLang, const std::string &toLang, const std::string &text); static void parseErrorResponse(
static void stringReplaceAll(std::string& context, const std::string& from, const std::string& to); const Json::Value& root,
static BOOL parseGoogleTranslate(const std::string result, std::string &translation, std::string &detectedLanguage); int& status,
std::string& err_msg);
static bool parseTranslation(
const Json::Value& root,
std::string& translation,
std::string& detected_lang);
static std::string getAPIKey();
};
static LLSD m_Header; /// Microsoft Translator v2 API handler.
static const char* m_GoogleURL; class LLBingTranslationHandler : public LLTranslationAPIHandler
static const char* m_GoogleLangSpec; {
static const char* m_AcceptHeader; LOG_CLASS(LLBingTranslationHandler);
static const char* m_AcceptType;
static const char* m_AgentHeader;
static const char* m_UserAgent;
static const char* m_GoogleData; public:
static const char* m_GoogleTranslation; /*virtual*/ void getTranslateURL(
static const char* m_GoogleLanguage; std::string &url,
const std::string &from_lang,
const std::string &to_lang,
const std::string &text) const;
/*virtual*/ void getKeyVerificationURL(
std::string &url,
const std::string &key) const;
/*virtual*/ bool parseResponse(
int& status,
const std::string& body,
std::string& translation,
std::string& detected_lang,
std::string& err_msg) const;
/*virtual*/ bool isConfigured() const;
private:
static std::string getAPIKey();
};
/**
* Entry point for machine translation services.
*
* Basically, to translate a string, we need to know the URL
* of a translation service, have a valid API for the service
* and be given the target language.
*
* Callers specify the string to translate and the target language,
* LLTranslate takes care of the rest.
*
* API keys for translation are taken from saved settings.
*/
class LLTranslate
{
LOG_CLASS(LLTranslate);
public :
typedef enum e_service {
SERVICE_BING,
SERVICE_GOOGLE,
} EService;
/**
* Subclasses are supposed to handle translation results (e.g. show them in chat)
*/
class TranslationReceiver: public LLHTTPClient::Responder
{
public:
/**
* Using mHandler, parse incoming response.
*
* Calls either handleResponse() or handleFailure()
* depending on the HTTP status code and parsing success.
*
* @see handleResponse()
* @see handleFailure()
* @see mHandler
*/
/*virtual*/ void completedRaw(
U32 http_status,
const std::string& reason,
const LLChannelDescriptors& channels,
const LLIOPipe::buffer_ptr_t& buffer);
protected:
friend class LLTranslate;
/// Remember source and target languages for subclasses to be able to filter inappropriate results.
TranslationReceiver(const std::string& from_lang, const std::string& to_lang);
/// Override point to handle successful translation.
virtual void handleResponse(const std::string &translation, const std::string &recognized_lang) = 0;
/// Override point to handle unsuccessful translation.
virtual void handleFailure(int status, const std::string& err_msg) = 0;
std::string mFromLang;
std::string mToLang;
const LLTranslationAPIHandler& mHandler;
};
/**
* Subclasses are supposed to handle API key verification result.
*/
class KeyVerificationReceiver: public LLHTTPClient::Responder
{
public:
EService getService() const;
protected:
/**
* Save the translation service the key belongs to.
*
* Subclasses need to know it.
*
* @see getService()
*/
KeyVerificationReceiver(EService service);
/**
* Parse verification response.
*
* Calls setVerificationStatus() with the verification status,
* which is true if HTTP status code is 200.
*
* @see setVerificationStatus()
*/
/*virtual*/ void completedRaw(
U32 http_status,
const std::string& reason,
const LLChannelDescriptors& channels,
const LLIOPipe::buffer_ptr_t& buffer);
/**
* Override point for subclasses to handle key verification status.
*/
virtual void setVerificationStatus(bool ok) = 0;
EService mService;
};
typedef boost::intrusive_ptr<TranslationReceiver> TranslationReceiverPtr;
typedef boost::intrusive_ptr<KeyVerificationReceiver> KeyVerificationReceiverPtr;
/**
* Translate given text.
*
* @param receiver Object to pass translation result to.
* @param from_lang Source language. Leave empty for auto-detection.
* @param to_lang Target language.
* @param mesg Text to translate.
*/
static void translateMessage(TranslationReceiverPtr &receiver, const std::string &from_lang, const std::string &to_lang, const std::string &mesg);
/**
* Verify given API key of a translation service.
*
* @param receiver Object to pass verification result to.
* @param key Key to verify.
*/
static void verifyKey(KeyVerificationReceiverPtr& receiver, const std::string& key);
/**
* @return translation target language
*/
static std::string getTranslateLanguage();
/**
* @return true if translation is configured properly.
*/
static bool isTranslationConfigured();
private:
static const LLTranslationAPIHandler& getPreferredHandler();
static const LLTranslationAPIHandler& getHandler(EService service);
static void sendRequest(const std::string& url, LLHTTPClient::ResponderPtr responder);
}; };
#endif #endif

26
indra/newview/llviewermessage.cpp
View File

@@ -2957,23 +2957,23 @@ void process_decline_callingcard(LLMessageSystem* msg, void**)
class ChatTranslationReceiver : public LLTranslate::TranslationReceiver class ChatTranslationReceiver : public LLTranslate::TranslationReceiver
{ {
public : public :
ChatTranslationReceiver(const std::string &fromLang, const std::string &toLang, LLChat *chat, ChatTranslationReceiver(const std::string &from_lang, const std::string &to_lang, LLChat *chat,
const BOOL history) const BOOL history)
: LLTranslate::TranslationReceiver(fromLang, toLang), : LLTranslate::TranslationReceiver(from_lang, to_lang),
m_chat(chat), m_chat(chat),
m_history(history) m_history(history)
{ {
} }
static boost::intrusive_ptr<ChatTranslationReceiver> build(const std::string &fromLang, const std::string &toLang, LLChat *chat, const BOOL history) static boost::intrusive_ptr<ChatTranslationReceiver> build(const std::string &from_lang, const std::string &to_lang, LLChat *chat, const BOOL history)
{ {
return boost::intrusive_ptr<ChatTranslationReceiver>(new ChatTranslationReceiver(fromLang, toLang, chat, history)); return boost::intrusive_ptr<ChatTranslationReceiver>(new ChatTranslationReceiver(from_lang, to_lang, chat, history));
} }
protected: protected:
void handleResponse(const std::string &translation, const std::string &detectedLanguage) void handleResponse(const std::string &translation, const std::string &detectedLanguage)
{ {
if (m_toLang != detectedLanguage) if (mToLang != detectedLanguage)
m_chat->mText += " (" + translation + ")"; m_chat->mText += " (" + translation + ")";
add_floater_chat(*m_chat, m_history); add_floater_chat(*m_chat, m_history);
@@ -2981,14 +2981,12 @@ protected:
delete m_chat; delete m_chat;
} }
void handleFailure() void handleFailure(int status, const std::string& err_msg)
{ {
LLTranslate::TranslationReceiver::handleFailure(); llwarns << "Translation failed for mesg " << m_chat << " toLang " << mToLang << " fromLang " << mFromLang << llendl;
m_chat->mText += " (?)"; m_chat->mText += " (?)";
add_floater_chat(*m_chat, m_history); add_floater_chat(*m_chat, m_history);
delete m_chat; delete m_chat;
} }
@@ -3017,14 +3015,12 @@ void check_translate_chat(const std::string &mesg, LLChat &chat, const BOOL hist
if (translate && chat.mSourceType != CHAT_SOURCE_SYSTEM) if (translate && chat.mSourceType != CHAT_SOURCE_SYSTEM)
{ {
// fromLang hardcoded to "" (autodetection) pending implementation of const std::string &from_lang = "";
// SVC-4879 const std::string &to_lang = LLTranslate::getTranslateLanguage();
const std::string &fromLang = "";
const std::string &toLang = LLTranslate::getTranslateLanguage();
LLChat *newChat = new LLChat(chat); LLChat *newChat = new LLChat(chat);
LLHTTPClient::ResponderPtr result = ChatTranslationReceiver::build(fromLang, toLang, newChat, history); LLTranslate::TranslationReceiverPtr result = ChatTranslationReceiver::build(from_lang, to_lang, newChat, history);
LLTranslate::translateMessage(result, fromLang, toLang, mesg); LLTranslate::translateMessage(result, from_lang, to_lang, mesg);
} }
else else
{ {