package com.hdl.photovoltaic.internet;
|
|
import android.text.TextUtils;
|
import android.util.Log;
|
|
import com.google.gson.Gson;
|
import com.google.gson.JsonObject;
|
import com.google.gson.JsonParser;
|
import com.hdl.photovoltaic.config.UserConfigManage;
|
|
import org.jetbrains.annotations.NotNull;
|
|
import java.io.BufferedReader;
|
import java.io.IOException;
|
import java.util.Objects;
|
import java.util.concurrent.TimeUnit;
|
|
import okhttp3.Cache;
|
import okhttp3.Call;
|
import okhttp3.Callback;
|
import okhttp3.MediaType;
|
import okhttp3.OkHttpClient;
|
import okhttp3.Request;
|
import okhttp3.RequestBody;
|
import okhttp3.Response;
|
import okhttp3.ResponseBody;
|
import okio.Buffer;
|
|
/**
|
* AI 聊天流式请求工具类
|
* 支持 SSE (Server-Sent Events) 流式响应
|
* 类似 ChatGPT 的流式输出效果
|
*/
|
public class ChatStreamClient {
|
// 单例实例
|
private static volatile ChatStreamClient instance;
|
|
/**
|
* 获取单例实例
|
*/
|
public static ChatStreamClient getInstance() {
|
if (instance == null) {
|
synchronized (ChatStreamClient.class) {
|
if (instance == null) {
|
instance = new ChatStreamClient();
|
}
|
}
|
}
|
return instance;
|
}
|
|
// ==================== 常量定义 ====================
|
private static final MediaType JSON = MediaType.get("application/json");
|
private static final String SSE_MEDIA_TYPE = "text/event-stream";
|
private static final String JSON_MEDIA_TYPE = "application/json";
|
private static final String DONE_FLAG = "[DONE]";
|
|
private final OkHttpClient okHttpClient = new OkHttpClient.Builder()
|
.connectTimeout(30, TimeUnit.SECONDS)
|
.readTimeout(0, TimeUnit.SECONDS)
|
.writeTimeout(30, TimeUnit.SECONDS)
|
// .connectionPool(new ConnectionPool(
|
// builder.maxIdleConnections,
|
// builder.keepAliveDuration,
|
// builder.timeUnit
|
// ))
|
// .retryOnConnectionFailure(builder.retryOnFailure)
|
// .addInterceptor(new HttpLoggingInterceptor()) // 可选：添加日志
|
.build();
|
; // HTTP 客户端
|
private final Gson gson = new Gson(); // JSON 解析器
|
private final String apiKey = "Bearer " + UserConfigManage.getInstance().getAgentSecret(); // API 密钥
|
private final String baseUrl = UserConfigManage.getInstance().getAgentUrl();// "https://agent.hdlcontrol.com/v1";; // 基础 URL
|
|
|
// ==================== 回调接口 ====================
|
public interface ChatCallback {
|
/**
|
* 收到消息片段时回调（流式输出）
|
*
|
* @param content 消息内容片段
|
*/
|
void onMessage(String content);
|
|
/**
|
* 消息完成时回调
|
*/
|
default void onComplete() {
|
}
|
|
/**
|
* 发生错误时回调
|
*
|
* @param error 错误信息
|
*/
|
default void onError(String error) {
|
}
|
|
/**
|
* 收到完整消息时回调（非流式模式使用）
|
*
|
* @param fullMessage 完整消息
|
*/
|
default void onFullMessage(String fullMessage) {
|
}
|
}
|
|
// ==================== 请求参数类 ====================
|
public static class ChatMode {
|
public boolean stream = true;
|
public boolean isGet = false;
|
public String url = "";
|
public Object data = null;
|
}
|
|
|
/**
|
* 发送流式聊天请求（完整参数）
|
*
|
* @param chatMode 请求参数
|
* @param callback 回调接口
|
* @return Cancelable 可取消的对象
|
*/
|
public Cancelable streamChat(ChatMode chatMode, ChatCallback callback) {
|
// // 确保是流式请求
|
// chatMode.stream = true;
|
|
// 构建 HTTP 请求
|
Request httpRequest = buildHttpRequest(chatMode);
|
// try {
|
// // 获取请求体
|
// if (httpRequest.body() != null) {
|
// Buffer buffer = new Buffer();
|
// httpRequest.body().writeTo(buffer);
|
// String body = buffer.readUtf8();
|
// // 注意：读取后记得关闭 buffer
|
// buffer.close();
|
// System.out.println("Request Body: " + body);
|
//
|
// }
|
// } catch (Exception e) {
|
//
|
// }
|
// 创建可取消的 Call
|
Call call = okHttpClient.newCall(httpRequest);
|
|
// 执行异步请求
|
call.enqueue(new StreamCallbackHandler(call, chatMode, callback));
|
|
// 返回可取消对象
|
return () -> {
|
if (!call.isCanceled()) {
|
call.cancel();
|
}
|
};
|
}
|
|
/**
|
* 发送非流式聊天请求（一次性返回）
|
*
|
* @param request 请求参数
|
* @return 完整响应
|
*/
|
public String chatSync(ChatMode request) {
|
// request.stream = false;
|
Request httpRequest = buildHttpRequest(request);
|
try (Response response = okHttpClient.newCall(httpRequest).execute()) {
|
if (!response.isSuccessful()) {
|
return response.message() + "(" + response.code() + ")";
|
}
|
return Objects.requireNonNull(response.body()).string();
|
} catch (Exception e) {
|
return e.getMessage();
|
}
|
}
|
|
|
/**
|
* 构建 HTTP 请求
|
*/
|
private Request buildHttpRequest(ChatMode ChatMode) {
|
|
String jsonBody = "";
|
if (ChatMode.data != null) {
|
jsonBody = gson.toJson(ChatMode.data);
|
}
|
String newUrl = baseUrl + ChatMode.url;
|
if (ChatMode.isGet) {
|
return new Request.Builder()
|
.url(newUrl)
|
.get()
|
.addHeader("Authorization", apiKey)
|
.addHeader("Cache-Control", "no-cache")
|
.addHeader("Connection", "keep-alive")
|
.build();
|
} else {
|
return new Request.Builder()
|
.url(newUrl)
|
.post(RequestBody.create(jsonBody, JSON))
|
.addHeader("Authorization", apiKey)
|
.addHeader("Accept", ChatMode.stream ? SSE_MEDIA_TYPE : JSON_MEDIA_TYPE)
|
.addHeader("Cache-Control", "no-cache")
|
.addHeader("Connection", "keep-alive")
|
.build();
|
}
|
}
|
|
|
/**
|
* 解析流式数据块
|
*/
|
private String parseStreamChunk(String data) {
|
if (data == null || data.isEmpty() || data.equals(DONE_FLAG)) {
|
return "";
|
}
|
try {
|
JsonObject json = JsonParser.parseString(data).getAsJsonObject();
|
String event = json.has("event") ? json.get("event").getAsString() : "";
|
if (event.equals("message")) {
|
return json.getAsString();
|
} else if (event.equals("message_end")) {
|
return DONE_FLAG;
|
} else if (event.equals("error")) {
|
return "error";
|
} else {
|
return "";
|
}
|
|
} catch (Exception e) {
|
// 解析失败，返回原始数据
|
return data;
|
}
|
}
|
|
// ==================== 流式响应处理器 ====================
|
private class StreamCallbackHandler implements Callback {
|
private final Call call;
|
private final ChatMode request;
|
private final ChatCallback callback;
|
private final StringBuilder fullContent = new StringBuilder();
|
|
public StreamCallbackHandler(Call call, ChatMode request, ChatCallback callback) {
|
this.call = call;
|
this.request = request;
|
this.callback = callback;
|
}
|
|
@Override
|
public void onFailure(@NotNull Call call, @NotNull IOException e) {
|
callback.onError("Network error: " + e.getMessage());
|
|
}
|
|
@Override
|
public void onResponse(@NotNull Call call, @NotNull Response response) {
|
if (!response.isSuccessful()) {
|
callback.onError("HTTP error: " + response.code());
|
response.close();
|
return;
|
}
|
// 检查内容类型
|
MediaType contentType = response.body().contentType();
|
if (contentType == null || !contentType.toString().startsWith(SSE_MEDIA_TYPE)) {
|
// 如果不是流式，可能是普通 JSON
|
try {
|
String body = response.body().string();
|
callback.onFullMessage(body);
|
} catch (IOException e) {
|
callback.onError("Parse error: " + e.getMessage());
|
}
|
response.close();
|
return;
|
}
|
|
// 流式处理
|
try (ResponseBody responseBody = response.body()) {
|
BufferedReader reader = new BufferedReader(responseBody.charStream());
|
String line;
|
while ((line = reader.readLine()) != null) {
|
if (call.isCanceled()) {
|
break;
|
}
|
|
if (line.startsWith("data:")) {
|
String data = line.substring(5).trim();
|
Log.d("流式处理==", line);
|
if (data.equals(DONE_FLAG)) {
|
callback.onComplete();
|
break;
|
}
|
String content = parseStreamChunk(data);
|
if (!TextUtils.isEmpty(content)) {
|
if (content.equals(DONE_FLAG)) {
|
callback.onComplete();
|
break;
|
} else if (content.equals("error")) {
|
callback.onError(data);
|
break;
|
}
|
fullContent.append(content);
|
callback.onMessage(content);
|
}
|
}
|
}
|
|
// // 如果没收到 DONE 但流结束了，也回调 complete
|
// if (isActive.get()) {
|
// callback.onComplete();
|
// }
|
|
} catch (IOException e) {
|
callback.onError("Stream error: " + e.getMessage());
|
}
|
}
|
}
|
|
// ==================== 可取消接口 ====================
|
public interface Cancelable {
|
void cancel();
|
}
|
|
|
/**
|
* 释放资源（应用退出时调用）
|
*/
|
public void shutdown() {
|
okHttpClient.dispatcher().executorService().shutdown();
|
okHttpClient.connectionPool().evictAll();
|
try {
|
Cache cache = okHttpClient.cache();
|
if (cache != null) {
|
cache.close();
|
}
|
} catch (IOException e) {
|
e.printStackTrace();
|
}
|
}
|
}
|
