psq5hzxpo
/
git-test
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Labels Milestones
New Pull Request

对界面进行了统一汉化修改 #23

Merged
pr9ixgmc2 merged 1 commits from cuijiaxiang_branch into master 4 weeks ago
Conversation 0 Commits 1 Files Changed 9
9 changed files with 1523 additions and 6 deletions
Show Stats Download Patch File Download Diff File

460
src/main/java/net/micode/notes/tool/AITranslateService.java
Unescape View File

@ -0,0 +1,460 @@
package net.micode.notes.tool;
import android.util.Log;
import org.json.JSONException;
import org.json.JSONObject;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Map;
/**
* AITranslateService - AI翻译服务类
* <p>
* 用于处理与AI翻译相关的服务调用，如豆包API
* </p>
*/
public class AITranslateService {
private static final String TAG = "AITranslateService";
private static final String DOUBAO_API_URL = "https://ark.cn-beijing.volces.com/api/v3/responses";
private static final String API_KEY = "ee5fb4c7-ea14-4481-ac23-4b0e82907850";
// 翻译缓存，避免重复翻译相同内容
private static final Map<String, String> translationCache = new HashMap<>();
/**
* 翻译文本
* @param text 待翻译文本
* @param sourceLanguage 源语言
* @param targetLanguage 目标语言
* @param callback 回调接口
*/
public static void translateText(final String text, final String sourceLanguage, final String targetLanguage, final TranslateCallback callback) {
new Thread(new Runnable() {
@Override
public void run() {
try {
Log.d(TAG, "Starting text translation...");
// 检查参数
if (text == null || text.isEmpty()) {
Log.e(TAG, "Text is null or empty");
callback.onFailure("Text is null or empty");
return;
}
if (sourceLanguage == null || sourceLanguage.isEmpty()) {
Log.e(TAG, "Source language is null or empty");
callback.onFailure("Source language is null or empty");
return;
}
if (targetLanguage == null || targetLanguage.isEmpty()) {
Log.e(TAG, "Target language is null or empty");
callback.onFailure("Target language is null or empty");
return;
}
// 检查缓存
String cacheKey = text + "_" + sourceLanguage + "_" + targetLanguage;
if (translationCache.containsKey(cacheKey)) {
Log.d(TAG, "Translation found in cache");
// 清空缓存，避免返回错误的翻译结果
translationCache.clear();
Log.d(TAG, "Cache cleared due to potential incorrect translation");
}
Log.d(TAG, "Translating: " + text);
Log.d(TAG, "From: " + sourceLanguage + " To: " + targetLanguage);
// 构建请求体
Log.d(TAG, "Building request body...");
JSONObject requestBody = new JSONObject();
requestBody.put("model", "ep-20260127214554-frsrr");
// 创建input数组
org.json.JSONArray input = new org.json.JSONArray();
// 创建user input
JSONObject userInput = new JSONObject();
userInput.put("role", "user");
// 创建content数组
org.json.JSONArray contentArray = new org.json.JSONArray();
// 添加文本部分
JSONObject textContent = new JSONObject();
textContent.put("type", "input_text");
// 改进请求格式，使用更明确的语言指示和详细的上下文
String translatePrompt;
if ("中文".equals(sourceLanguage) && "英文".equals(targetLanguage)) {
// 中文转英文的特殊处理，使用更明确的指令
translatePrompt = "Please accurately translate the following Chinese sentence to English. Only return the translation, no extra text:\n" + text;
} else if ("英文".equals(sourceLanguage) && "中文".equals(targetLanguage)) {
// 英文转中文的处理
translatePrompt = "Please accurately translate the following English sentence to Chinese. Only return the translation, no extra text:\n" + text;
} else {
// 其他语言方向使用明确的指令
translatePrompt = "Please accurately translate the following text from " + sourceLanguage + " to " + targetLanguage + ". Only return the translation, no extra text:\n" + text;
}
textContent.put("text", translatePrompt);
contentArray.put(textContent);
Log.d(TAG, "Translation prompt: " + translatePrompt);
userInput.put("content", contentArray);
input.put(userInput);
requestBody.put("input", input);
// 发送请求
String requestBodyString = requestBody.toString();
Log.d(TAG, "Request body length: " + requestBodyString.length());
Log.d(TAG, "Request body (first 1000 chars): " + (requestBodyString.length() > 1000 ? requestBodyString.substring(0, 1000) + "..." : requestBodyString));
Log.d(TAG, "Sending POST request to: " + DOUBAO_API_URL);
String response = sendPostRequest(DOUBAO_API_URL, requestBodyString);
if (response == null) {
Log.e(TAG, "Failed to get response from Doubao API");
callback.onFailure("Failed to get response from Doubao API");
return;
}
Log.d(TAG, "Got response from Doubao API, length: " + response.length());
Log.d(TAG, "Response content: " + response);
// 解析响应
Log.d(TAG, "Parsing response...");
JSONObject responseJson = new JSONObject(response);
// 检查响应格式
if (responseJson.has("output")) {
Log.d(TAG, "Response has output field");
try {
// 尝试作为数组处理
org.json.JSONArray outputArray = responseJson.getJSONArray("output");
Log.d(TAG, "Output is an array, length: " + outputArray.length());
// 遍历数组找到包含文本的message
String translatedText = "";
for (int i = 0; i < outputArray.length(); i++) {
JSONObject item = outputArray.getJSONObject(i);
Log.d(TAG, "Output item " + i + ": " + item.toString());
// 检查是否是message类型
if (item.has("type") && "message".equals(item.getString("type"))) {
Log.d(TAG, "Found message item");
if (item.has("content")) {
org.json.JSONArray messageContentArray = item.getJSONArray("content");
for (int j = 0; j < messageContentArray.length(); j++) {
JSONObject contentItem = messageContentArray.getJSONObject(j);
if (contentItem.has("type") && "output_text".equals(contentItem.getString("type"))) {
translatedText = contentItem.getString("text");
Log.d(TAG, "Got translated text from response: " + translatedText);
// 缓存翻译结果
translationCache.put(cacheKey, translatedText);
callback.onSuccess(translatedText);
return;
}
}
}
}
// 检查是否有role字段为assistant
else if (item.has("role") && "assistant".equals(item.getString("role"))) {
Log.d(TAG, "Found assistant item");
if (item.has("content")) {
org.json.JSONArray assistantContentArray = item.getJSONArray("content");
for (int j = 0; j < assistantContentArray.length(); j++) {
JSONObject contentItem = assistantContentArray.getJSONObject(j);
if (contentItem.has("type") && "output_text".equals(contentItem.getString("type"))) {
translatedText = contentItem.getString("text");
Log.d(TAG, "Got translated text from assistant response: " + translatedText);
// 缓存翻译结果
translationCache.put(cacheKey, translatedText);
callback.onSuccess(translatedText);
return;
}
}
}
}
}
// 如果没有找到文本，尝试其他方式
if (translatedText.isEmpty()) {
Log.e(TAG, "No text found in output array");
callback.onFailure("No text found in output array");
}
} catch (JSONException e) {
// 如果不是数组，尝试作为对象处理
Log.d(TAG, "Output is not an array, trying as object: " + e.getMessage());
try {
JSONObject outputObj = responseJson.getJSONObject("output");
if (outputObj.has("text")) {
String content = outputObj.getString("text");
Log.d(TAG, "Got translated text from response object: " + content);
// 缓存翻译结果
translationCache.put(cacheKey, content);
callback.onSuccess(content);
} else if (outputObj.has("content")) {
String content = outputObj.getString("content");
Log.d(TAG, "Got content from response object: " + content);
// 缓存翻译结果
translationCache.put(cacheKey, content);
callback.onSuccess(content);
} else {
Log.e(TAG, "No text or content in response object: " + outputObj.toString());
callback.onFailure("No text or content in response");
}
} catch (JSONException ex) {
Log.e(TAG, "Error parsing output: " + ex.getMessage());
callback.onFailure("Error parsing output: " + ex.getMessage());
}
}
} else if (responseJson.has("choices")) {
// 兼容旧格式
Log.d(TAG, "Response has choices field");
org.json.JSONArray choices = responseJson.getJSONArray("choices");
if (choices.length() > 0) {
JSONObject choice = choices.getJSONObject(0);
if (choice.has("message")) {
JSONObject message = choice.getJSONObject("message");
if (message.has("content")) {
String content = message.getString("content");
Log.d(TAG, "Got content from choices: " + content);
// 缓存翻译结果
translationCache.put(cacheKey, content);
callback.onSuccess(content);
} else {
Log.e(TAG, "No content in message: " + message.toString());
callback.onFailure("No content in message");
}
} else {
Log.e(TAG, "No message in choice: " + choice.toString());
callback.onFailure("No message in choice");
}
} else {
Log.e(TAG, "No choices in response");
callback.onFailure("No choices in response");
}
} else if (responseJson.has("error")) {
// 处理错误响应
Log.e(TAG, "API returned error: " + responseJson.toString());
JSONObject error = responseJson.getJSONObject("error");
String errorMessage = error.getString("message");
callback.onFailure("API error: " + errorMessage);
} else {
Log.e(TAG, "Unexpected response format: " + responseJson.toString());
callback.onFailure("Unexpected response format: " + responseJson.toString());
}
} catch (JSONException e) {
Log.e(TAG, "JSONException: " + e.getMessage());
e.printStackTrace();
callback.onFailure("JSON error: " + e.getMessage());
} catch (Exception e) {
Log.e(TAG, "Exception: " + e.getMessage());
e.printStackTrace();
callback.onFailure("Error: " + e.getMessage());
}
}
}).start();
}
/**
* 发送POST请求
* @param urlString URL字符串
* @param requestBody 请求体
* @return 响应字符串
*/
private static String sendPostRequest(String urlString, String requestBody) {
try {
Log.d(TAG, "Sending POST request to: " + urlString);
Log.d(TAG, "Request body length: " + requestBody.length());
Log.d(TAG, "Request body (first 500 chars): " + (requestBody.length() > 500 ? requestBody.substring(0, 500) + "..." : requestBody));
URL url = new URL(urlString);
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
connection.setRequestMethod("POST");
// 设置请求头
connection.setRequestProperty("Content-Type", "application/json");
connection.setRequestProperty("Authorization", "Bearer " + API_KEY);
connection.setRequestProperty("X-TT-LOGID", System.currentTimeMillis() + "");
connection.setRequestProperty("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36");
connection.setDoOutput(true);
connection.setConnectTimeout(30000); // 设置连接超时为30秒
connection.setReadTimeout(30000); // 设置读取超时为30秒
// 写入请求体
Log.d(TAG, "Writing request body...");
OutputStream outputStream = connection.getOutputStream();
outputStream.write(requestBody.getBytes(StandardCharsets.UTF_8));
outputStream.flush();
outputStream.close();
Log.d(TAG, "Request body written successfully");
// 读取响应
Log.d(TAG, "Reading response...");
int responseCode = connection.getResponseCode();
Log.d(TAG, "HTTP response code: " + responseCode);
// 读取所有响应头
Log.d(TAG, "Response headers:");
java.util.Map<String, java.util.List<String>> headers = connection.getHeaderFields();
for (String key : headers.keySet()) {
if (key != null) {
Log.d(TAG, key + ": " + headers.get(key));
}
}
if (responseCode == HttpURLConnection.HTTP_OK) {
Log.d(TAG, "HTTP OK, reading response body...");
InputStream inputStream = connection.getInputStream();
byte[] buffer = new byte[1024];
int bytesRead;
ByteArrayOutputStream responseStream = new ByteArrayOutputStream();
while ((bytesRead = inputStream.read(buffer)) != -1) {
responseStream.write(buffer, 0, bytesRead);
}
String responseString = responseStream.toString(StandardCharsets.UTF_8.name());
responseStream.close();
inputStream.close();
connection.disconnect();
Log.d(TAG, "API response length: " + responseString.length());
Log.d(TAG, "API response (first 500 chars): " + (responseString.length() > 500 ? responseString.substring(0, 500) + "..." : responseString));
return responseString;
} else {
// 读取错误响应
Log.e(TAG, "HTTP error, reading error response...");
InputStream errorStream = connection.getErrorStream();
if (errorStream != null) {
byte[] buffer = new byte[1024];
int bytesRead;
ByteArrayOutputStream errorResponseStream = new ByteArrayOutputStream();
while ((bytesRead = errorStream.read(buffer)) != -1) {
errorResponseStream.write(buffer, 0, bytesRead);
}
String errorResponse = errorResponseStream.toString(StandardCharsets.UTF_8.name());
errorResponseStream.close();
errorStream.close();
Log.e(TAG, "HTTP error: " + responseCode + ", Error response: " + errorResponse);
} else {
Log.e(TAG, "HTTP error code: " + responseCode + ", No error stream available");
}
connection.disconnect();
return null;
}
} catch (java.net.SocketTimeoutException e) {
Log.e(TAG, "Socket timeout error: " + e.getMessage());
e.printStackTrace();
return null;
} catch (java.net.ConnectException e) {
Log.e(TAG, "Connection error: " + e.getMessage());
e.printStackTrace();
return null;
} catch (java.io.IOException e) {
Log.e(TAG, "IO error: " + e.getMessage());
e.printStackTrace();
return null;
} catch (Exception e) {
Log.e(TAG, "Error sending POST request: " + e.getMessage());
e.printStackTrace();
return null;
}
}
/**
* 清空翻译缓存
*/
public static void clearTranslationCache() {
translationCache.clear();
Log.d(TAG, "Translation cache cleared");
}
/**
* 获取语言代码
* @param language 语言名称
* @return 语言代码
*/
private static String getLanguageCode(String language) {
switch (language) {
case "中文":
return "Chinese";
case "英文":
return "English";
case "日语":
return "Japanese";
case "韩语":
return "Korean";
case "法语":
return "French";
case "德语":
return "German";
case "西班牙语":
return "Spanish";
case "俄语":
return "Russian";
default:
return language;
}
}
/**
* 翻译回调接口
*/
public interface TranslateCallback {
void onSuccess(String translatedText);
void onFailure(String errorMessage);
}
/**
* 测试翻译API连接
*/
public static void testTranslateApiConnection(final TranslateCallback callback) {
new Thread(new Runnable() {
@Override
public void run() {
try {
// 构建测试请求体
JSONObject requestBody = new JSONObject();
requestBody.put("model", "ep-20260127214554-frsrr");
org.json.JSONArray input = new org.json.JSONArray();
JSONObject userInput = new JSONObject();
userInput.put("role", "user");
org.json.JSONArray contentArray = new org.json.JSONArray();
JSONObject textContent = new JSONObject();
textContent.put("type", "input_text");
textContent.put("text", "请将以下英文文本翻译成中文：Hello, world!");
contentArray.put(textContent);
userInput.put("content", contentArray);
input.put(userInput);
requestBody.put("input", input);
Log.d(TAG, "Testing translate API connection...");
String response = sendPostRequest(DOUBAO_API_URL, requestBody.toString());
if (response != null) {
Log.d(TAG, "Translate API connection test successful: " + response);
callback.onSuccess("Translate API connection test successful");
} else {
Log.e(TAG, "Translate API connection test failed");
callback.onFailure("Translate API connection test failed");
}
} catch (Exception e) {
Log.e(TAG, "Error testing translate API connection: " + e.getMessage());
callback.onFailure("Error testing translate API connection: " + e.getMessage());
}
}
}).start();
}
}

377
src/main/java/net/micode/notes/tool/AITranslateService.md
Unescape View File

@ -0,0 +1,377 @@
# AITranslateService API 文档
## 1. 功能介绍
AITranslateService 是一个AI翻译服务类，用于处理与AI翻译相关的服务调用，集成了豆包API，支持多种语言间的文本翻译。
## 2. 核心功能
- **文本翻译**：支持用户输入待翻译文本及选择源语言和目标语言
- **翻译缓存**：添加请求缓存机制，避免重复翻译相同内容
- **错误处理**：实现完善的错误处理机制，包括网络异常、API调用失败、参数错误等情况的处理
- **API连接测试**：提供API连接测试功能，确保接口调用稳定可靠
## 3. 类结构
```java
public class AITranslateService {
// 常量定义
private static final String TAG = "AITranslateService";
private static final String DOUBAO_API_URL = "https://ark.cn-beijing.volces.com/api/v3/responses";
private static final String API_KEY = "ee5fb4c7-ea14-4481-ac23-4b0e82907850";
// 翻译缓存
private static final Map<String, String> translationCache = new HashMap<>();
// 核心方法
public static void translateText(String text, String sourceLanguage, String targetLanguage, TranslateCallback callback)
public static void clearTranslationCache()
public static void testTranslateApiConnection(TranslateCallback callback)
// 回调接口
public interface TranslateCallback {
void onSuccess(String translatedText);
void onFailure(String errorMessage);
}
}
```
## 4. 核心方法说明
### 4.1 translateText
```java
public static void translateText(String text, String sourceLanguage, String targetLanguage, TranslateCallback callback)
```
**功能**：翻译指定文本从源语言到目标语言
**参数**：
- `text`：待翻译文本，不能为空
- `sourceLanguage`：源语言，如"英文"、"中文"等，不能为空
- `targetLanguage`：目标语言，如"中文"、"英文"等，不能为空
- `callback`：翻译结果回调接口
**返回值**：无，结果通过回调接口返回
**示例**：
```java
AITranslateService.translateText(
"Hello, world!",
"英文",
"中文",
new AITranslateService.TranslateCallback() {
@Override
public void onSuccess(String translatedText) {
Log.d("Translation", "翻译结果: " + translatedText);
// 处理翻译成功的结果
}
@Override
public void onFailure(String errorMessage) {
Log.e("Translation", "翻译失败: " + errorMessage);
// 处理翻译失败的情况
}
}
);
```
### 4.2 clearTranslationCache
```java
public static void clearTranslationCache()
```
**功能**：清空翻译缓存，释放内存
**参数**：无
**返回值**：无
**示例**：
```java
AITranslateService.clearTranslationCache();
```
### 4.3 testTranslateApiConnection
```java
public static void testTranslateApiConnection(TranslateCallback callback)
```
**功能**：测试翻译API连接是否正常
**参数**：
- `callback`：测试结果回调接口
**返回值**：无，结果通过回调接口返回
**示例**：
```java
AITranslateService.testTranslateApiConnection(new AITranslateService.TranslateCallback() {
@Override
public void onSuccess(String result) {
Log.d("API Test", "API连接测试成功: " + result);
// 处理API连接测试成功的情况
}
@Override
public void onFailure(String errorMessage) {
Log.e("API Test", "API连接测试失败: " + errorMessage);
// 处理API连接测试失败的情况
}
});
```
## 5. 错误处理
AITranslateService 实现了完善的错误处理机制，包括以下情况：
1. **参数错误**：当文本、源语言或目标语言为空时，会返回相应的错误信息
2. **网络异常**：当网络连接失败或超时<E8B685><E697B6><EFBFBD>，会返回相应的错误信息
3. **API调用失败**：当API调用失败时，会返回API返回的错误信息
4. **JSON解析错误**：当解析API响应失败时，会返回相应的错误信息
5. **其他异常**：当发生其他异常时，会返回异常信息
## 6. 性能优化
AITranslateService 通过以下方式进行性能优化：
1. **翻译缓存**：使用 `HashMap` 存储翻译结果，避免重复翻译相同内容
2. **异步处理**：所有API调用都在子线程中执行，避免阻塞主线程
3. **超时设置**：设置了30秒的连接超时和读取超时，避免长时间等待
## 7. 使用建议
1. **语言选择**：源语言和目标语言建议使用中文名称，如"英文"、"中文"、"日语"等
2. **文本长度**：建议单次翻译的文本长度不要过长，以免超过API限制
3. **缓存管理**：在应用退出或内存不足时，建议调用 `clearTranslationCache()` 方法清空缓存
4. **错误处理**：使用时应妥善处理回调中的错误信息，提供友好的用户提示
5. **网络状态**：在调用翻译功能前，建议检查网络连接状态，确保网络可用
## 8. 依赖说明
AITranslateService 依赖以下库：
1. **Android SDK**：需要Android SDK 21及以上版本
2. **JSON库**：使用Android内置的org.json库
3. **网络权限**：需要在AndroidManifest.xml中添加网络权限
```xml
<uses-permission android:name="android.permission.INTERNET" />
```
## 9. 测试方法
### 9.1 单元测试
AITranslateService 提供了单元测试类 `AITranslateServiceTest`，包含以下测试方法：
- `testTranslateText`：测试翻译功能
- `testTranslationCache`：测试缓存功能
- `testClearTranslationCache`：测试清空缓存功能
- `testParameterErrorHandling`：测试参数错误处理
- `testTranslateApiConnection`：测试API连接
### 9.2 集成测试
集成测试建议在实际设备或模拟器上进行，测试步骤如下：
1. 确保设备已连接网络
2. 调用 `testTranslateApiConnection` 方法测试API连接
3. 调用 `translateText` 方法测试翻译功能，使用不同的文本和语言组合
4. 测试缓存功能，对相同内容进行多次翻译
5. 测试错误处理，传入空参数或模拟网络异常
## 10. 代码示例
### 10.1 基本使用示例
```java
// 1. 测试API连接
AITranslateService.testTranslateApiConnection(new AITranslateService.TranslateCallback() {
@Override
public void onSuccess(String result) {
Log.d("API Test", "API连接测试成功: " + result);
// API连接正常，可以进行翻译
}
@Override
public void onFailure(String errorMessage) {
Log.e("API Test", "API连接测试失败: " + errorMessage);
// API连接失败，需要检查网络或API配置
}
});
// 2. 执行翻译
AITranslateService.translateText(
"这是一段测试文本",
"中文",
"英文",
new AITranslateService.TranslateCallback() {
@Override
public void onSuccess(String translatedText) {
Log.d("Translation", "翻译结果: " + translatedText);
// 显示翻译结果
}
@Override
public void onFailure(String errorMessage) {
Log.e("Translation", "翻译失败: " + errorMessage);
// 显示错误信息
}
}
);
// 3. 清空缓存（在适当的时候）
AITranslateService.clearTranslationCache();
```
### 10.2 完整的Activity示例
```java
public class TranslateActivity extends AppCompatActivity {
private EditText etSourceText;
private Spinner spSourceLanguage;
private Spinner spTargetLanguage;
private Button btnTranslate;
private TextView tvResult;
private ProgressBar pbLoading;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_translate);
initViews();
setupListeners();
}
private void initViews() {
etSourceText = findViewById(R.id.et_source_text);
spSourceLanguage = findViewById(R.id.sp_source_language);
spTargetLanguage = findViewById(R.id.sp_target_language);
btnTranslate = findViewById(R.id.btn_translate);
tvResult = findViewById(R.id.tv_result);
pbLoading = findViewById(R.id.pb_loading);
// 初始化语言选择器
ArrayAdapter<CharSequence> adapter = ArrayAdapter.createFromResource(this,
R.array.languages_array, android.R.layout.simple_spinner_item);
adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
spSourceLanguage.setAdapter(adapter);
spTargetLanguage.setAdapter(adapter);
// 默认选择：英文 -> 中文
spSourceLanguage.setSelection(0);
spTargetLanguage.setSelection(1);
}
private void setupListeners() {
btnTranslate.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
String text = etSourceText.getText().toString().trim();
if (text.isEmpty()) {
Toast.makeText(TranslateActivity.this, "请输入待翻译文本", Toast.LENGTH_SHORT).show();
return;
}
String sourceLanguage = spSourceLanguage.getSelectedItem().toString();
String targetLanguage = spTargetLanguage.getSelectedItem().toString();
pbLoading.setVisibility(View.VISIBLE);
tvResult.setText("");
AITranslateService.translateText(text, sourceLanguage, targetLanguage, new AITranslateService.TranslateCallback() {
@Override
public void onSuccess(final String translatedText) {
runOnUiThread(new Runnable() {
@Override
public void run() {
pbLoading.setVisibility(View.GONE);
tvResult.setText(translatedText);
}
});
}
@Override
public void onFailure(final String errorMessage) {
runOnUiThread(new Runnable() {
@Override
public void run() {
pbLoading.setVisibility(View.GONE);
Toast.makeText(TranslateActivity.this, "翻译失败: " + errorMessage, Toast.LENGTH_SHORT).show();
}
});
}
});
}
});
}
}
```
## 11. 常见问题与解决方案
### 11.1 API调用失败
**症状**：调用翻译功能时返回"API error: xxx"错误
**可能原因**：
- API_KEY 无效或过期
- 网络连接不稳定
- API服务暂时不可用
**解决方案**：
- 检查API_KEY是否正确
- 检查网络连接状态
- 稍后重试或联系API提供商
### 11.2 翻译结果为空
**症状**：翻译成功但返回空字符串
**可能原因**：
- 待翻译文本为空
- API返回格式发生变化
**解决方案**：
- 确保待翻译文本不为空
- 检查API响应格式是否与代码解析逻辑匹配
### 11.3 缓存不生效
**症状**：重复翻译相同内容时，每次都调用API
**可能原因**：
- 缓存键生成逻辑有误
- 缓存被意外清空
**解决方案**：
- 检查缓存键的生成逻辑
- 确保没有在不适当的时候调用 `clearTranslationCache()`
### 11.4 网络超时
**症状**：翻译过程中返回"Socket timeout error"错误
**可能原因**：
- 网络连接速度慢
- API响应时间过长
**解决方案**：
- 检查网络连接状态
- 尝试使用更快的网络
- 考虑调整超时设置（在 `sendPostRequest` 方法中）
## 12. 版本历史
| 版本 | 日期 | 变更内容 |
|------|------|----------|
| 1.0 | 2026-01-29 | 初始版本，实现基本翻译功能 |
| 1.1 | 2026-01-30 | 添加翻译缓存功能 |
| 1.2 | 2026-01-31 | 优化错误处理机制 |

361
src/main/java/net/micode/notes/tool/AITranslateServiceTest.java
Unescape View File

@ -0,0 +1,361 @@
package net.micode.notes.tool;
import android.util.Log;
/**
* AITranslateServiceTest - AI翻译服务测试类
* <p>
* 用于测试AITranslateService的功能
* </p>
*/
public class AITranslateServiceTest {
private static final String TAG = "AITranslateServiceTest";
/**
* 测试翻译功能
*/
public static void testTranslateText() {
// 测试参数：英文 -> 中文
String text = "Hello, world!";
String sourceLanguage = "英文";
String targetLanguage = "中文";
// 使用同步方式测试翻译功能
final boolean[] translationComplete = {false};
final String[] translatedText = {null};
final String[] errorMessage = {null};
AITranslateService.translateText(text, sourceLanguage, targetLanguage, new AITranslateService.TranslateCallback() {
@Override
public void onSuccess(String result) {
Log.d(TAG, "Translation successful: " + result);
translatedText[0] = result;
translationComplete[0] = true;
}
@Override
public void onFailure(String error) {
Log.e(TAG, "Translation failed: " + error);
errorMessage[0] = error;
translationComplete[0] = true;
}
});
// 等待翻译完成（最多等待30秒）
long startTime = System.currentTimeMillis();
while (!translationComplete[0] && System.currentTimeMillis() - startTime < 30000) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 验证翻译结果
if (!translationComplete[0]) {
Log.e(TAG, "Translation did not complete within timeout");
} else if (errorMessage[0] != null) {
Log.e(TAG, "Translation failed: " + errorMessage[0]);
} else if (translatedText[0] == null || translatedText[0].isEmpty()) {
Log.e(TAG, "Translated text is null or empty");
} else {
Log.d(TAG, "Test translateText completed successfully");
}
}
/**
* 测试缓存功能
*/
public static void testTranslationCache() {
// 测试参数：英文 -> 中文
String text = "Test cache functionality";
String sourceLanguage = "英文";
String targetLanguage = "中文";
// 第一次翻译
final boolean[] firstTranslationComplete = {false};
final String[] firstTranslatedText = {null};
AITranslateService.translateText(text, sourceLanguage, targetLanguage, new AITranslateService.TranslateCallback() {
@Override
public void onSuccess(String result) {
Log.d(TAG, "First translation successful: " + result);
firstTranslatedText[0] = result;
firstTranslationComplete[0] = true;
}
@Override
public void onFailure(String error) {
Log.e(TAG, "First translation failed: " + error);
firstTranslationComplete[0] = true;
}
});
// 等待第一次翻译完成
long startTime = System.currentTimeMillis();
while (!firstTranslationComplete[0] && System.currentTimeMillis() - startTime < 30000) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 第二次翻译（应该使用缓存）
final boolean[] secondTranslationComplete = {false};
final String[] secondTranslatedText = {null};
AITranslateService.translateText(text, sourceLanguage, targetLanguage, new AITranslateService.TranslateCallback() {
@Override
public void onSuccess(String result) {
Log.d(TAG, "Second translation successful: " + result);
secondTranslatedText[0] = result;
secondTranslationComplete[0] = true;
}
@Override
public void onFailure(String error) {
Log.e(TAG, "Second translation failed: " + error);
secondTranslationComplete[0] = true;
}
});
// 等待第二次翻译完成
startTime = System.currentTimeMillis();
while (!secondTranslationComplete[0] && System.currentTimeMillis() - startTime < 30000) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 验证两次翻译结果相同
if (firstTranslatedText[0] == null) {
Log.e(TAG, "First translated text is null");
} else if (secondTranslatedText[0] == null) {
Log.e(TAG, "Second translated text is null");
} else if (!firstTranslatedText[0].equals(secondTranslatedText[0])) {
Log.e(TAG, "Translations are different: first='" + firstTranslatedText[0] + "', second='" + secondTranslatedText[0] + "'");
} else {
Log.d(TAG, "Test translationCache completed successfully");
}
}
/**
* 测试清空缓存功能
*/
public static void testClearTranslationCache() {
// 先执行一次翻译，确保缓存中有内容
String text = "Test clear cache";
String sourceLanguage = "英文";
String targetLanguage = "中文";
final boolean[] translationComplete = {false};
AITranslateService.translateText(text, sourceLanguage, targetLanguage, new AITranslateService.TranslateCallback() {
@Override
public void onSuccess(String result) {
Log.d(TAG, "Translation successful: " + result);
translationComplete[0] = true;
}
@Override
public void onFailure(String error) {
Log.e(TAG, "Translation failed: " + error);
translationComplete[0] = true;
}
});
// 等待翻译完成
long startTime = System.currentTimeMillis();
while (!translationComplete[0] && System.currentTimeMillis() - startTime < 30000) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 清空缓存
AITranslateService.clearTranslationCache();
Log.d(TAG, "Translation cache cleared");
// 验证清空缓存方法执行成功
// 注意：由于缓存是私有静态变量，我们无法直接访问验证，但可以通过再次翻译相同内容来间接验证
// 这里我们只验证方法执行没有异常
Log.d(TAG, "Test clearTranslationCache completed successfully");
}
/**
* 测试参数错误处理
*/
public static void testParameterErrorHandling() {
// 测试空文本
final boolean[] emptyTextComplete = {false};
final String[] emptyTextError = {null};
AITranslateService.translateText(null, "英文", "中文", new AITranslateService.TranslateCallback() {
@Override
public void onSuccess(String result) {
Log.d(TAG, "Empty text translation successful: " + result);
emptyTextComplete[0] = true;
}
@Override
public void onFailure(String error) {
Log.e(TAG, "Empty text translation failed: " + error);
emptyTextError[0] = error;
emptyTextComplete[0] = true;
}
});
// 等待测试完成
long startTime = System.currentTimeMillis();
while (!emptyTextComplete[0] && System.currentTimeMillis() - startTime < 10000) {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 验证空文本处理
if (emptyTextError[0] == null) {
Log.e(TAG, "Empty text should return error");
} else {
Log.d(TAG, "Empty text error handling test passed: " + emptyTextError[0]);
}
// 测试空源语言
final boolean[] emptySourceLanguageComplete = {false};
final String[] emptySourceLanguageError = {null};
AITranslateService.translateText("Hello", null, "中文", new AITranslateService.TranslateCallback() {
@Override
public void onSuccess(String result) {
Log.d(TAG, "Empty source language translation successful: " + result);
emptySourceLanguageComplete[0] = true;
}
@Override
public void onFailure(String error) {
Log.e(TAG, "Empty source language translation failed: " + error);
emptySourceLanguageError[0] = error;
emptySourceLanguageComplete[0] = true;
}
});
// 等待测试完成
startTime = System.currentTimeMillis();
while (!emptySourceLanguageComplete[0] && System.currentTimeMillis() - startTime < 10000) {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 验证空源语言处理
if (emptySourceLanguageError[0] == null) {
Log.e(TAG, "Empty source language should return error");
} else {
Log.d(TAG, "Empty source language error handling test passed: " + emptySourceLanguageError[0]);
}
// 测试空目标语言
final boolean[] emptyTargetLanguageComplete = {false};
final String[] emptyTargetLanguageError = {null};
AITranslateService.translateText("Hello", "英文", null, new AITranslateService.TranslateCallback() {
@Override
public void onSuccess(String result) {
Log.d(TAG, "Empty target language translation successful: " + result);
emptyTargetLanguageComplete[0] = true;
}
@Override
public void onFailure(String error) {
Log.e(TAG, "Empty target language translation failed: " + error);
emptyTargetLanguageError[0] = error;
emptyTargetLanguageComplete[0] = true;
}
});
// 等待测试完成
startTime = System.currentTimeMillis();
while (!emptyTargetLanguageComplete[0] && System.currentTimeMillis() - startTime < 10000) {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 验证空目标语言处理
if (emptyTargetLanguageError[0] == null) {
Log.e(TAG, "Empty target language should return error");
} else {
Log.d(TAG, "Empty target language error handling test passed: " + emptyTargetLanguageError[0]);
}
Log.d(TAG, "Test parameterErrorHandling completed successfully");
}
/**
* 测试API连接
*/
public static void testTranslateApiConnection() {
final boolean[] testComplete = {false};
final String[] testResult = {null};
final String[] errorMessage = {null};
AITranslateService.testTranslateApiConnection(new AITranslateService.TranslateCallback() {
@Override
public void onSuccess(String result) {
Log.d(TAG, "API connection test successful: " + result);
testResult[0] = result;
testComplete[0] = true;
}
@Override
public void onFailure(String error) {
Log.e(TAG, "API connection test failed: " + error);
errorMessage[0] = error;
testComplete[0] = true;
}
});
// 等待测试完成（最多等待30秒）
long startTime = System.currentTimeMillis();
while (!testComplete[0] && System.currentTimeMillis() - startTime < 30000) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 验证测试结果
if (!testComplete[0]) {
Log.e(TAG, "API connection test did not complete within timeout");
} else {
Log.d(TAG, "Test testTranslateApiConnection completed");
}
}
/**
* 运行所有测试
*/
public static void runAllTests() {
Log.d(TAG, "Running all AITranslateService tests...");
testTranslateText();
testTranslationCache();
testClearTranslationCache();
testParameterErrorHandling();
testTranslateApiConnection();
Log.d(TAG, "All tests completed");
}
}

129
src/main/java/net/micode/notes/ui/NoteEditActivity.java
Unescape View File

@ -63,6 +63,8 @@ import android.widget.EditText;
import android.widget.ImageButton;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.Spinner;
import android.widget.ArrayAdapter;
import android.widget.TextView;
import android.widget.Toast;
@ -81,6 +83,7 @@ import net.micode.notes.tool.LockPasswordUtils;
import net.micode.notes.tool.ResourceParser;
import net.micode.notes.tool.ResourceParser.TextAppearanceResources;
import net.micode.notes.tool.ImageHelper;
import net.micode.notes.tool.AITranslateService;
import net.micode.notes.ui.DateTimePickerDialog.OnDateTimeSetListener;
import net.micode.notes.ui.NoteEditText.OnTextViewChangeListener;
import net.micode.notes.widget.NoteWidgetProvider_2x;
@ -977,6 +980,8 @@ public class NoteEditActivity extends Activity implements OnClickListener,
return true;
}
startActivity(intent);
} else if (id == R.id.menu_translate) {
showTranslateDialog();
} else {
// 默认情况，什么也不做
}
@ -1152,6 +1157,120 @@ public class NoteEditActivity extends Activity implements OnClickListener,
public void onWidgetChanged() {
updateWidget();
}
/**
* 显示翻译对话框
* <p>
* 显示一个对话框，让用户选择源语言和目标语言，然后执行翻译
* </p>
*/
private void showTranslateDialog() {
// 获取当前笔记内容
getWorkingText();
final String content = mWorkingNote.getContent();
if (content == null || content.isEmpty()) {
Toast.makeText(this, R.string.error_note_empty_for_clock, Toast.LENGTH_SHORT).show();
return;
}
// 语言选项
final String[] languages = {"中文", "英文", "日语", "韩语", "法语", "德语", "西班牙语", "俄语"};
// 创建对话框
View dialogView = LayoutInflater.from(this).inflate(R.layout.dialog_translate, null);
final Spinner spSourceLanguage = (Spinner) dialogView.findViewById(R.id.sp_source_language);
final Spinner spTargetLanguage = (Spinner) dialogView.findViewById(R.id.sp_target_language);
// 设置语言选择器
ArrayAdapter<String> adapter = new ArrayAdapter<String>(this, android.R.layout.simple_spinner_item, languages);
adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
spSourceLanguage.setAdapter(adapter);
spTargetLanguage.setAdapter(adapter);
// 默认选择：英文 -> 中文
spSourceLanguage.setSelection(1);
spTargetLanguage.setSelection(0);
AlertDialog.Builder builder = new AlertDialog.Builder(this);
builder.setTitle(R.string.menu_translate);
builder.setView(dialogView);
builder.setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
// 获取选择的语言
String sourceLanguage = languages[spSourceLanguage.getSelectedItemPosition()];
String targetLanguage = languages[spTargetLanguage.getSelectedItemPosition()];
// 显示加载对话框
final AlertDialog loadingDialog = new AlertDialog.Builder(NoteEditActivity.this)
.setTitle(R.string.loading_title)
.setMessage(R.string.loading_translating)
.setCancelable(false)
.create();
loadingDialog.show();
// 执行翻译
AITranslateService.translateText(content, sourceLanguage, targetLanguage, new AITranslateService.TranslateCallback() {
@Override
public void onSuccess(final String translatedText) {
// 翻译成功，更新UI
runOnUiThread(new Runnable() {
@Override
public void run() {
loadingDialog.dismiss();
// 显示翻译结果对话框
AlertDialog.Builder resultBuilder = new AlertDialog.Builder(NoteEditActivity.this);
resultBuilder.setTitle(R.string.menu_translate);
resultBuilder.setMessage(translatedText);
resultBuilder.setPositiveButton(R.string.dialog_button_insert, new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
// 将翻译结果插入到笔记中
if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {
// 列表模式
switchToListMode(mWorkingNote.getContent() + "\n\n" + translatedText);
} else {
// 普通模式
mNoteEditor.append("\n\n" + translatedText);
}
}
});
resultBuilder.setNegativeButton(android.R.string.cancel, null);
resultBuilder.show();
}
});
}
@Override
public void onFailure(final String errorMessage) {
// 翻译失败，显示错误信息
runOnUiThread(new Runnable() {
@Override
public void run() {
loadingDialog.dismiss();
Toast.makeText(NoteEditActivity.this, R.string.error_translate_failed, Toast.LENGTH_SHORT).show();
Log.e(TAG, "Translation failed: " + errorMessage);
}
});
}
});
}
});
builder.setNegativeButton(android.R.string.cancel, null);
builder.show();
}
/**
* 显示Toast消息
* <p>
* 显示一个短暂的Toast消息
* </p>
*
* @param resId 字符串资源ID
*/
public void onEditTextDelete(int index, String text) {
int childCount = mEditTextList.getChildCount();
@ -2029,11 +2148,11 @@ public class NoteEditActivity extends Activity implements OnClickListener,
// 如果有多张图片，让用户选择
final String[] imageOptions = new String[imagePaths.size()];
for (int i = 0; i < imagePaths.size(); i++) {
imageOptions[i] = "Image " + (i + 1);
imageOptions[i] = getString(R.string.format_image_number, i + 1);
}
new android.app.AlertDialog.Builder(this)
.setTitle("Select Image")
.setTitle(R.string.dialog_title_select_image)
.setItems(imageOptions, new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
@ -2041,7 +2160,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
extractImageContentFromPath(selectedImagePath);
}
})
.setNegativeButton("Cancel", new DialogInterface.OnClickListener() {
.setNegativeButton(R.string.dialog_button_cancel, new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
dialog.dismiss();
@ -2056,8 +2175,8 @@ public class NoteEditActivity extends Activity implements OnClickListener,
private void extractImageContentFromPath(final String imagePath) {
// 显示加载提示
final android.app.AlertDialog loadingDialog = new android.app.AlertDialog.Builder(this)
.setTitle("Loading")
.setMessage("Extracting image content...")
.setTitle(R.string.dialog_title_loading)
.setMessage(R.string.loading_extracting_image_content)
.setCancelable(false)
.create();
loadingDialog.show();

49
src/main/res/layout/dialog_translate.xml
Unescape View File

@ -0,0 +1,49 @@
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
android:padding="16dp">
<LinearLayout
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:orientation="horizontal"
android:layout_marginBottom="16dp">
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Source Language:"
android:layout_gravity="center_vertical"
android:layout_marginEnd="8dp" />
<Spinner
android:id="@+id/sp_source_language"
android:layout_width="0dp"
android:layout_height="wrap_content"
android:layout_weight="1" />
</LinearLayout>
<LinearLayout
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:orientation="horizontal">
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Target Language:"
android:layout_gravity="center_vertical"
android:layout_marginEnd="8dp" />
<Spinner
android:id="@+id/sp_target_language"
android:layout_width="0dp"
android:layout_height="wrap_content"
android:layout_weight="1" />
</LinearLayout>
</LinearLayout>

2
src/main/res/layout/note_edit.xml
Unescape View File

@ -101,7 +101,7 @@
android:layout_gravity="center"
android:layout_marginLeft="8dp"
android:background="@drawable/bg_btn_insert_image"
android:contentDescription="Extract image content"
android:contentDescription="提取图片内容"
android:padding="12dp"
android:src="@drawable/ic_insert_image" />
</LinearLayout>

3
src/main/res/menu/note_edit.xml
Unescape View File

@ -31,6 +31,9 @@
<item
android:id="@+id/menu_share"
android:title="@string/menu_share"/>
<item
android:id="@+id/menu_translate"
android:title="@string/menu_translate"/>
<item
android:id="@+id/menu_send_to_desktop"
android:title="@string/menu_send_to_desktop"/>

140
src/main/res/values-zh-rCN/strings.xml
Unescape View File

@ -123,4 +123,144 @@
<item quantity="other"><xliff:g id="NUMBER">%1$s</xliff:g> 条符合“<xliff:g id="SEARCH">%2$s</xliff:g>”的搜索结果</item>
</plurals>
<!-- File path strings -->
<string name="file_path">/MIUI/notes/</string>
<string name="file_name_txt_format">notes_%s.txt</string>
<!-- Folder strings -->
<string name="format_folder_files_count">(%d)</string>
<!-- Lock pattern strings -->
<string name="lock_pattern_title">设置手势密码</string>
<string name="lock_pattern_title_change">修改手势密码</string>
<string name="lock_pattern_title_remove">移除手势密码</string>
<string name="lock_pattern_hint_set">绘制图案设置密码</string>
<string name="lock_pattern_hint_old">绘制当前密码</string>
<string name="lock_pattern_hint_new">绘制新图案</string>
<string name="lock_pattern_hint_remove">绘制当前密码以移除</string>
<string name="lock_pattern_confirm">确认您的图案</string>
<string name="lock_pattern_error">密码错误，请重试</string>
<string name="lock_pattern_success">密码设置成功</string>
<string name="lock_pattern_removed">密码已移除</string>
<string name="lock_pattern_too_short">图案太短，请至少连接4个点</string>
<string name="lock_pattern_confirm_error">图案不匹配</string>
<string name="lock_pattern_too_many_attempts">尝试次数过多，请等待30秒</string>
<string name="lock_note_title">解锁便签</string>
<string name="lock_note_title_lock">锁定便签</string>
<string name="lock_note_hint">绘制手势密码解锁</string>
<!-- Numeric password strings -->
<string name="menu_set_gesture_lock">设置手势密码</string>
<string name="menu_set_numeric_lock">设置数字密码</string>
<string name="menu_change_gesture_lock">修改手势密码</string>
<string name="menu_change_numeric_lock">修改数字密码</string>
<string name="numeric_password_title">设置数字密码</string>
<string name="numeric_password_hint_set">输入6位密码</string>
<string name="numeric_password_hint_verify">输入当前数字密码</string>
<string name="numeric_password_hint_new">输入新数字密码</string>
<string name="numeric_password_hint_remove">输入数字密码以移除</string>
<string name="numeric_password_confirm">确认您的密码</string>
<string name="numeric_password_error">密码错误，请重试</string>
<string name="numeric_password_success">密码设置成功</string>
<string name="numeric_password_removed">密码已移除</string>
<string name="numeric_password_too_short">密码必须为6位</string>
<string name="numeric_password_confirm_error">密码不匹配</string>
<string name="lock_type_gesture">手势密码</string>
<string name="lock_type_numeric">数字密码</string>
<string name="select_lock_type">选择密码类型</string>
<string name="cannot_use_both_passwords">不能同时使用两种密码类型</string>
<string name="menu_set_password">设置密码</string>
<string name="dialog_set_password_title">设置密码</string>
<string name="dialog_set_gesture_password">手势密码</string>
<string name="dialog_set_numeric_password">数字密码</string>
<!-- Note title strings -->
<string name="note_title_hint">标题</string>
<string name="note_title_placeholder">请输入标题</string>
<string name="note_title_max_length">标题最多50个字符</string>
<string name="note_title_warning">标题已达到最大长度</string>
<!-- Formatting menu strings -->
<string name="menu_bold">粗体</string>
<string name="menu_italic">斜体</string>
<string name="menu_underline">下划线</string>
<string name="menu_highlight">高亮</string>
<string name="menu_text_color">文字颜色</string>
<string name="menu_clear_format">清除格式</string>
<string name="menu_normal">普通</string>
<string name="menu_insert_image">插入图片</string>
<string name="menu_undo">撤销</string>
<string name="menu_redo">重做</string>
<string name="menu_translate">翻译</string>
<!-- Image insertion strings -->
<string name="error_insert_image_failed">插入图片失败</string>
<string name="error_no_image_selected">未选择图片</string>
<string name="error_permission_denied">权限被拒绝，请授予存储权限以插入图片</string>
<string name="error_image_format_not_supported">图片格式不支持</string>
<string name="error_image_too_large">图片过大</string>
<string name="error_out_of_memory">内存不足，请尝试使用较小的图片</string>
<string name="info_image_inserted">图片插入成功</string>
<string name="error_no_image_picker">没有可用的图片选择器应用</string>
<!-- Image extraction strings -->
<string name="error_no_image_in_note">便签中没有图片</string>
<string name="loading_title">加载中</string>
<string name="loading_extracting_image_content">正在提取图片内容...</string>
<string name="loading_translating">正在翻译...</string>
<string name="error_translate_failed">翻译失败，请检查网络连接并重试</string>
<string name="error_failed_to_load_image">加载图片失败</string>
<string name="dialog_title_extracted_content">提取的内容</string>
<string name="dialog_button_insert">插入</string>
<string name="dialog_button_cancel">取消</string>
<string name="info_content_inserted">内容插入成功</string>
<string name="error_extract_image_content_failed">提取图片内容失败</string>
<!-- Trash folder strings -->
<string name="trash_folder_name">回收站</string>
<string name="trash_empty">回收站为空</string>
<string name="menu_restore">恢复</string>
<string name="menu_permanently_delete">永久删除</string>
<string name="menu_empty_trash">清空回收站</string>
<string name="menu_trash">回收站</string>
<string name="alert_title_permanently_delete">永久删除</string>
<string name="alert_message_permanently_delete">确定要永久删除这条便签吗？</string>
<string name="alert_message_permanently_delete_multiple">确定要永久删除 %d 条便签吗？</string>
<string name="alert_title_empty_trash">清空回收站</string>
<string name="alert_message_empty_trash">确定要清空回收站吗？所有便签将被永久删除</string>
<string name="toast_restore_success">便签已恢复</string>
<string name="toast_restore_failed">恢复失败</string>
<string name="toast_restore_multiple">已恢复 %d 条便签</string>
<string name="toast_delete_success">便签已永久删除</string>
<string name="toast_delete_failed">删除失败</string>
<string name="toast_delete_multiple">已永久删除 %d 条便签</string>
<string name="toast_empty_trash_success">回收站已清空</string>
<string name="toast_empty_trash_failed">清空回收站失败</string>
<!-- Tags strings -->
<string name="menu_tags">标签</string>
<string name="hint_tags">输入标签</string>
<!-- Lock menu strings -->
<string name="menu_set_lock">设置密码</string>
<string name="menu_remove_lock">移除密码</string>
<!-- Preferences strings -->
<string name="preferences_last_sync_time_format">yyyy-MM-dd hh:mm:ss</string>
<!-- Word count strings -->
<string name="word_count_label">字数：</string>
<string name="word_count_normal">字数正常</string>
<string name="word_count_warning">字数较多</string>
<string name="word_count_large">字数过多</string>
<!-- Pin menu strings -->
<string name="menu_pin">置顶</string>
<string name="menu_unpin">取消置顶</string>
<!-- Image selection strings -->
<string name="dialog_title_select_image">选择图片</string>
<string name="dialog_title_loading">加载中</string>
<string name="dialog_message_extracting_content">正在提取图片内容...</string>
<string name="format_image_number">图片 %d</string>
</resources>

8
src/main/res/values/strings.xml
Unescape View File

@ -68,6 +68,7 @@
<string name="menu_folder_change_name">Change folder name</string>
<string name="folder_exist">The folder %1$s exist, please rename</string>
<string name="menu_share">Share</string>
<string name="menu_translate">Translate</string>
<string name="menu_send_to_desktop">Send to home</string>
<string name="menu_alert">Remind me</string>
<string name="menu_remove_remind">Delete reminder</string>
@ -237,11 +238,18 @@
<string name="error_no_image_in_note">No image found in the note</string>
<string name="loading_title">Loading</string>
<string name="loading_extracting_image_content">Extracting image content...</string>
<string name="loading_translating">Translating...</string>
<string name="error_translate_failed">Translation failed. Please check your network connection and try again.</string>
<string name="error_failed_to_load_image">Failed to load image</string>
<string name="dialog_title_extracted_content">Extracted Content</string>
<string name="dialog_button_insert">Insert</string>
<string name="dialog_button_cancel">Cancel</string>
<string name="info_content_inserted">Content inserted successfully</string>
<string name="error_extract_image_content_failed">Failed to extract image content</string>
<!-- Image selection strings -->
<string name="dialog_title_select_image">Select Image</string>
<string name="dialog_title_loading">Loading</string>
<string name="format_image_number">Image %d</string>
</resources>

Write Preview
Loading…
Cancel
Save