socketWriter.go

最新推荐文章于 2019-05-06 22:27:12 发布
转载 最新推荐文章于 2019-05-06 22:27:12 发布 · 70 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：http://www.cnblogs.com/zhangboyu/p/7449501.html

本文介绍了一个使用Go语言实现的Socket日志组件，该组件能够通过网络连接发送不同级别的日志信息，并支持异步记录及回调函数等功能。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

package blog4go

import (
"bytes"
"fmt"
"net"
"sync"
)

// SocketWriter 是一个socket日志结构体
type SocketWriter struct {
level LevelType  //日志级别

closed bool   //链接是否关闭

// log hook
hook      Hook  //回调函数
hookLevel LevelType  //回调函数 对应的日志级别
hookAsync bool   //日志是否异步记录

// socket
writer net.Conn  //网络链接

lock *sync.Mutex  //读写锁
}

// NewSocketWriter  创建一个单例线程写
func NewSocketWriter(network string, address string) (err error) {
singltonLock.Lock()
defer singltonLock.Unlock()
if nil != blog {
return ErrAlreadyInit
}

socketWriter, err := newSocketWriter(network, address)
if nil != err {
return err
}

blog = socketWriter
return nil
}

// newSocketWriter 创建一个写socket  但是不是单例
func newSocketWriter(network string, address string) (socketWriter *SocketWriter, err error) {
socketWriter = new(SocketWriter)
socketWriter.level = DEBUG
socketWriter.closed = false
socketWriter.lock = new(sync.Mutex)

// log hook
socketWriter.hook = nil
socketWriter.hookLevel = DEBUG

conn, err := net.Dial(network, address)
if nil != err {
return nil, err
}
socketWriter.writer = conn

blog = socketWriter
return socketWriter, nil
}
//写日志   并设置日志级别  如果链接是关闭的 直接返回
func (writer *SocketWriter) write(level LevelType, args ...interface{}) {
writer.lock.Lock()
defer writer.lock.Unlock()

if writer.closed {
return
}

defer func() {
// call log hook
if nil != writer.hook && !(level < writer.hookLevel) {
if writer.hookAsync {
go func(level LevelType, args ...interface{}) {
writer.hook.Fire(level, args...)
}(level, args...)

} else {
writer.hook.Fire(level, args...)

}
}
}()

buffer := bytes.NewBuffer(timeCache.Format())
buffer.WriteString(level.prefix())
buffer.WriteString(fmt.Sprint(args...))
writer.writer.Write(buffer.Bytes())
}
//写日志
func (writer *SocketWriter) writef(level LevelType, format string, args ...interface{}) {
writer.lock.Lock()
defer writer.lock.Unlock()

if writer.closed {
return
}

defer func() {

// call log hook
if nil != writer.hook && !(level < writer.hookLevel) {
if writer.hookAsync {
go func(level LevelType, format string, args ...interface{}) {
writer.hook.Fire(level, fmt.Sprintf(format, args...))
}(level, format, args...)

} else {
writer.hook.Fire(level, fmt.Sprintf(format, args...))
}
}
}()

buffer := bytes.NewBuffer(timeCache.Format())
buffer.WriteString(level.prefix())
buffer.WriteString(fmt.Sprintf(format, args...))
writer.writer.Write(buffer.Bytes())
}

// 获取日志级别
func (writer *SocketWriter) Level() LevelType {
return writer.level
}

//设置日志级别
func (writer *SocketWriter) SetLevel(level LevelType) {
writer.level = level
}

//设置回调函数
func (writer *SocketWriter) SetHook(hook Hook) {
writer.hook = hook
}

//设置同步书写文件  如果为真的话
func (writer *SocketWriter) SetHookAsync(async bool) {
writer.hookAsync = async
}

//设置回调函数对应日志级别
func (writer *SocketWriter) SetHookLevel(level LevelType) {
writer.hookLevel = level
}

// TimeRotated暂时什么都不做
func (writer *SocketWriter) TimeRotated() bool {
return false
}

// SetTimeRotated暂时什么都不做
func (writer *SocketWriter) SetTimeRotated(timeRotated bool) {
return
}

// Retentions暂时什么都不做
func (writer *SocketWriter) Retentions() int64 {
return 0
}

// SetRetentions暂时什么都不做
func (writer *SocketWriter) SetRetentions(retentions int64) {
return
}

// RotateSize暂时什么都不做
func (writer *SocketWriter) RotateSize() int64 {
return 0
}

// SetRotateSize暂时什么都不做
func (writer *SocketWriter) SetRotateSize(rotateSize int64) {
return
}

// RotateLines暂时什么都不做
func (writer *SocketWriter) RotateLines() int {
return 0
}

// SetRotateLines暂时什么都不做
func (writer *SocketWriter) SetRotateLines(rotateLines int) {
return
}

// Colored 暂时什么都不做
func (writer *SocketWriter) Colored() bool {
return false
}

// SetColored 暂时什么都不做
func (writer *SocketWriter) SetColored(colored bool) {
return
}

// Close将关闭写流
func (writer *SocketWriter) Close() {
writer.lock.Lock()
defer writer.lock.Unlock()
if writer.closed {
return
}

writer.writer.Close()
writer.writer = nil
writer.closed = true
}

// flush暂时什么都不做
func (writer *SocketWriter) flush() {
return
}

// Trace  日志级别
func (writer *SocketWriter) Trace(args ...interface{}) {
if nil == writer.writer || TRACE < writer.level {
return
}

writer.write(TRACE, args...)
}

// Trac  日志级别
func (writer *SocketWriter) Tracef(format string, args ...interface{}) {
if nil == writer.writer || TRACE < writer.level {
return
}

writer.writef(TRACE, format, args...)
}

// Debug日志级别
func (writer *SocketWriter) Debug(args ...interface{}) {
if nil == writer.writer || DEBUG < writer.level {
return
}

writer.write(DEBUG, args...)
}

// Debugf日志级别
func (writer *SocketWriter) Debugf(format string, args ...interface{}) {
if nil == writer.writer || DEBUG < writer.level {
return
}

writer.writef(DEBUG, format, args...)
}

// Info日志级别
func (writer *SocketWriter) Info(args ...interface{}) {
if nil == writer.writer || INFO < writer.level {
return
}

writer.write(INFO, args...)
}

// Infof日志级别
func (writer *SocketWriter) Infof(format string, args ...interface{}) {
if nil == writer.writer || INFO < writer.level {
return
}

writer.writef(INFO, format, args...)
}

// Warn日志级别
func (writer *SocketWriter) Warn(args ...interface{}) {
if nil == writer.writer || WARNING < writer.level {
return
}

writer.write(WARNING, args...)
}

// Warnf日志级别
func (writer *SocketWriter) Warnf(format string, args ...interface{}) {
if nil == writer.writer || WARNING < writer.level {
return
}

writer.writef(WARNING, format, args...)
}

// Error 日志级别
func (writer *SocketWriter) Error(args ...interface{}) {
if nil == writer.writer || ERROR < writer.level {
return
}

writer.write(ERROR, args...)
}

// Errorf日志级别
func (writer *SocketWriter) Errorf(format string, args ...interface{}) {
if nil == writer.writer || ERROR < writer.level {
return
}

writer.writef(ERROR, format, args...)
}

// Critical日志级别
func (writer *SocketWriter) Critical(args ...interface{}) {
if nil == writer.writer || CRITICAL < writer.level {
return
}

writer.write(CRITICAL, args...)
}

// Criticalf 日志级别
func (writer *SocketWriter) Criticalf(format string, args ...interface{}) {
if nil == writer.writer || CRITICAL < writer.level {
return
}

writer.writef(CRITICAL, format, args...)
}

转载于:https://www.cnblogs.com/zhangboyu/p/7449501.html

Socket通信之Write实现流程
森海的博客
03-27 7673
1 分析write在进程间通信的实现过程        在内核中，socket是与文件指针挂钩的，因此就可以通过open、read、write像操作文件一样对socket进行操作；而write的过程相当于socket数据发送的过程。接下来，我们研究socket的数据发送流程。 1、从socket (AF_UNIX, SOCK_STREAM, 0)入手，经过跟踪会调到unix_create函数
socket编程中BufferedWriter与PrintStream输出方式的区别详解
花开归矣的博客
03-02 1596
1、两者区别 （1）BufferedWriter write()要输出换行标识，要调用flush()刷新缓冲区 （2）PrintStream 直接调用输出方法即可 2、BufferedWriter代码演示 （1）客户端 bw.write(xxx); bw.newLine(); bw.flush(); 三条语句必须同时出现 package soc...
socket编程中write、read和send、recv之间的区别
热门推荐
petershina的专栏
09-05 8万+
一旦，我们建立好了tcp连接之后，我们就可以把得到的fd当作文件描述符来使用。 由此网络程序里最基本的函数就是read和write函数了。 ssize_t write(int fd, const void*buf,size_t nbytes); write函数将buf中的nbytes字节内容写入文件描述符fd.成功时返回写的字节数.失败时返回-1. 并设置errno变量. 在网络程序中,当我
socket_write socket_send区别
pzqingchong的专栏
10-23 6797
socket_write写到缓冲(本地套接字缓冲) 实际有可能未发送出去 socket_send 已经从套接字缓冲发出
C++socket编程write()、read()简介及与send()、recv()的区别
Lei Gong's blog
05-06 7299
write 函数原型： ssize_t write(int fd, const void*buf,size_t nbytes) write函数将buf中的nbytes字节内容写入文件描述符fd.成功时返回写的字节数.失败时返回-1.并设置errno变量. 在网络程序中,当我们向套接字文件描述符写时有两可能： 1)write的返回值大于0,表示写了部分或者是全部的数据. 这样我们用一个while循...
package com.example.demoapplication; import android.Manifest; import android.content.pm.PackageManager; import android.media.AudioFormat; import android.media.AudioRecord; import android.media.MediaRecorder; import android.os.Build; import android.os.Bundle; import android.os.Handler; import android.os.Looper; import android.os.Message; import android.util.Base64; import android.util.Log; import android.widget.Button; import android.widget.Toast; import androidx.annotation.NonNull; import androidx.appcompat.app.AppCompatActivity; import androidx.core.app.ActivityCompat; import androidx.core.content.ContextCompat; import org.json.JSONException; import org.json.JSONObject; import java.io.BufferedWriter; import java.io.IOException; import java.io.OutputStreamWriter; import java.net.ServerSocket; import java.net.Socket; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicBoolean; public class MainActivity extends AppCompatActivity { private static final String TAG = "AudioRecorder"; private Button startRecordButton; private Button stopRecordButton; private Button uploadButton; private AudioRecord audioRecord; private static final int SAMPLE_RATE = 44100; private static final int BUFFER_SIZE; static { int minBufferSize = 0; if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.CUPCAKE) { minBufferSize = AudioRecord.getMinBufferSize( SAMPLE_RATE, AudioFormat.CHANNEL_IN_MONO, AudioFormat.ENCODING_PCM_16BIT ); } // 确保缓冲区大小有效 BUFFER_SIZE = Math.max(minBufferSize, 4096); } private ScheduledExecutorService scheduler; private AtomicBoolean isRecording = new AtomicBoolean(false); private static final int PERMISSION_REQUEST_CODE = 1; private final ExecutorService executorService = Executors.newCachedThreadPool(); private ServerSocket serverSocket; private volatile boolean isServerRunning = true; private volatile Socket clientSocket; private volatile BufferedWriter socketWriter; // 主线程消息处理器 private final Handler handler = new Handler(Looper.getMainLooper()) { @Override public void handleMessage(@NonNull Message msg) { switch (msg.what) { case 0x11: // 客户端连接成功 Toast.makeText(MainActivity.this, "客户端已连接", Toast.LENGTH_SHORT).show(); break; case 0x12: // 开始录音 Toast.makeText(MainActivity.this, "开始录音", Toast.LENGTH_SHORT).show(); break; case 0x13: // 数据发送成功 // 减少Toast频率，避免刷屏 if (Math.random() < 0.1) { // 10%概率显示 Toast.makeText(MainActivity.this, "录音数据已发送", Toast.LENGTH_SHORT).show(); } break; case 0x14: // 停止录音 Toast.makeText(MainActivity.this, "停止录音", Toast.LENGTH_SHORT).show(); break; case 0x15: // 控制指令 Toast.makeText(MainActivity.this, "收到控制指令：" + msg.obj.toString(), Toast.LENGTH_SHORT).show(); break; case 0x16: // 错误消息 Toast.makeText(MainActivity.this, "错误: " + msg.obj.toString(), Toast.LENGTH_LONG).show(); break; case 0x17: // 网络状态 Toast.makeText(MainActivity.this, "网络: " + msg.obj.toString(), Toast.LENGTH_SHORT).show(); break; } } }; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); initViews(); setupClickListeners(); checkPermissions(); startServer(30000); } private void initViews() { startRecordButton = findViewById(R.id.startRecordButton); stopRecordButton = findViewById(R.id.stopRecordButton); uploadButton = findViewById(R.id.uploadButton); stopRecordButton.setEnabled(false); uploadButton.setEnabled(false); } private void setupClickListeners() { startRecordButton.setOnClickListener(v -> startRecording()); stopRecordButton.setOnClickListener(v -> stopRecording()); uploadButton.setOnClickListener(v -> uploadRecording()); } private void checkPermissions() { if (ContextCompat.checkSelfPermission(this, Manifest.permission.RECORD_AUDIO) != PackageManager.PERMISSION_GRANTED) { ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.RECORD_AUDIO}, PERMISSION_REQUEST_CODE); } } private void startRecording() { // 检查权限 if (ContextCompat.checkSelfPermission(this, Manifest.permission.RECORD_AUDIO) != PackageManager.PERMISSION_GRANTED) { sendErrorMessage("没有录音权限"); return; } // 检查是否正在录音 if (isRecording.get() || audioRecord != null) { sendErrorMessage("录音已在进行中"); return; } // 检查网络连接 if (clientSocket == null || clientSocket.isClosed() || socketWriter == null) { sendErrorMessage("客户端未连接，无法录音"); return; } try { // 初始化 AudioRecord audioRecord = new AudioRecord( MediaRecorder.AudioSource.MIC, SAMPLE_RATE, AudioFormat.CHANNEL_IN_MONO, AudioFormat.ENCODING_PCM_16BIT, BUFFER_SIZE ); // 检查初始化状态 if (audioRecord.getState() != AudioRecord.STATE_INITIALIZED) { throw new IllegalStateException("AudioRecord 初始化失败"); } // 开始录音 audioRecord.startRecording(); isRecording.set(true); // 更新按钮状态 startRecordButton.setEnabled(false); stopRecordButton.setEnabled(true); uploadButton.setEnabled(false); // 创建定时任务发送音频数据 scheduler = Executors.newSingleThreadScheduledExecutor(); scheduler.scheduleAtFixedRate(this::uploadAudioData, 0, 100, TimeUnit.MILLISECONDS); // 增加频率 handler.sendEmptyMessage(0x12); // 发送开始录音的消息 // 发送开始录音控制指令 sendControlPacket("startRecorder"); } catch (Exception e) { Log.e(TAG, "录音启动失败", e); sendErrorMessage("录音启动失败: " + e.getMessage()); releaseAudioResources(); } } private void stopRecording() { if (!isRecording.get()) return; isRecording.set(false); releaseAudioResources(); // 更新按钮状态 stopRecordButton.setEnabled(false); uploadButton.setEnabled(true); handler.sendEmptyMessage(0x14); // 发送停止录音的消息 // 发送停止录音控制指令 sendControlPacket("stopRecor"); } private void releaseAudioResources() { if (audioRecord != null) { try { if (audioRecord.getRecordingState() == AudioRecord.RECORDSTATE_RECORDING) { audioRecord.stop(); } } catch (IllegalStateException e) { Log.e(TAG, "停止录音失败", e); } audioRecord.release(); audioRecord = null; } if (scheduler != null) { scheduler.shutdownNow(); scheduler = null; } } private void uploadAudioData() { if (!isRecording.get() || clientSocket == null || clientSocket.isClosed() || socketWriter == null) { Log.w(TAG, "无法发送音频数据: 录音未进行或客户端未连接"); return; } byte[] buffer = new byte[BUFFER_SIZE]; try { int bytesRead = audioRecord.read(buffer, 0, BUFFER_SIZE); if (bytesRead > 0) { // 创建JSON数据包 JSONObject json = new JSONObject(); json.put("type", "recording"); json.put("data", Base64.encodeToString(buffer, 0, bytesRead, Base64.NO_WRAP)); // 使用NO_WRAP避免换行符 // 发送数据 synchronized (this) { if (socketWriter != null) { socketWriter.write(json.toString()); socketWriter.write("\n\n"); // 添加双换行作为结束标识 socketWriter.flush(); } } handler.sendEmptyMessage(0x13); // 发送录音数据的消息 } } catch (Exception e) { Log.e(TAG, "发送音频数据失败", e); sendErrorMessage("发送音频数据失败: " + e.getMessage()); } } private void sendControlPacket(String type) { if (clientSocket == null || clientSocket.isClosed() || socketWriter == null) { sendErrorMessage("无法发送控制指令: 客户端未连接"); return; } try { JSONObject packet = new JSONObject(); packet.put("type", type); packet.put("data", JSONObject.NULL); synchronized (this) { if (socketWriter != null) { socketWriter.write(packet.toString()); socketWriter.write("\n\n"); // 双换行作为结束标识 socketWriter.flush(); } } Log.i(TAG, "控制指令发送成功: " + type); } catch (Exception e) { Log.e(TAG, "发送控制指令失败", e); sendErrorMessage("发送控制指令失败: " + e.getMessage()); } } private void sendErrorMessage(String message) { Message msg = handler.obtainMessage(0x16, message); handler.sendMessage(msg); } private void sendNetworkMessage(String message) { Message msg = handler.obtainMessage(0x17, message); handler.sendMessage(msg); } private void uploadRecording() { Toast.makeText(this, "该模式下无需上传文件，已实时发送", Toast.LENGTH_SHORT).show(); } private void startServer(int port) { executorService.execute(() -> { try { serverSocket = new ServerSocket(port); Log.i(TAG, "服务器启动，监听端口: " + port); sendNetworkMessage("服务器启动"); while (isServerRunning) { try { Socket socket = serverSocket.accept(); clientSocket = socket; // 创建输出流 synchronized (this) { socketWriter = new BufferedWriter( new OutputStreamWriter(socket.getOutputStream(), "UTF-8")); } handler.sendEmptyMessage(0x11); // 发送客户端连接成功的消息 Log.i(TAG, "客户端已连接: " + socket.getInetAddress()); sendNetworkMessage("客户端已连接"); // 启动双向通信处理 executorService.execute(() -> startCommunication(socket)); } catch (IOException e) { if (isServerRunning) { Log.e(TAG, "接受连接失败", e); sendErrorMessage("接受连接失败: " + e.getMessage()); } } } } catch (IOException e) { Log.e(TAG, "服务器启动失败", e); runOnUiThread(() -> Toast.makeText(MainActivity.this, "服务器启动失败: " + e.getMessage(), Toast.LENGTH_LONG).show()); } finally { closeServerSocket(); } }); } private void startCommunication(Socket socket) { try (java.io.BufferedReader reader = new java.io.BufferedReader( new java.io.InputStreamReader(socket.getInputStream(), "UTF-8"))) { StringBuilder packetBuilder = new StringBuilder(); int c; while ((c = reader.read()) != -1 && isServerRunning) { char ch = (char) c; packetBuilder.append(ch); // 检测到连续两个换行符，表示一个完整的数据包结束 if (packetBuilder.length() >= 2 && packetBuilder.charAt(packetBuilder.length() - 2) == '\n' && packetBuilder.charAt(packetBuilder.length() - 1) == '\n') { String packet = packetBuilder.toString().trim(); packetBuilder.setLength(0); // 清空构建器 if (!packet.isEmpty()) { try { JSONObject jsonObject = new JSONObject(packet); handleReceivedPacket(jsonObject); } catch (JSONException e) { Log.w(TAG, "JSON解析失败: " + packet, e); } } } } } catch (IOException e) { if (isServerRunning) { Log.e(TAG, "通信中断", e); runOnUiThread(() -> Toast.makeText(MainActivity.this, "通信中断: " + e.getMessage(), Toast.LENGTH_SHORT).show()); } } finally { closeSocket(socket); } } private void handleReceivedPacket(JSONObject jsonObject) { try { String type = jsonObject.getString("type"); Object data = jsonObject.opt("data"); // 发送消息到主线程进行显示 Message msg = handler.obtainMessage(0x15, type + ": " + data); handler.sendMessage(msg); Log.i(TAG, "收到控制指令: " + type); // 根据不同类型执行不同操作 switch (type) { case "start_recording": runOnUiThread(this::startRecording); break; case "stop_recording": runOnUiThread(this::stopRecording); break; case "ping": sendResponse("pong"); break; } } catch (JSONException e) { Log.e(TAG, "处理数据包失败", e); } } private void sendResponse(String responseType) { if (clientSocket == null || clientSocket.isClosed() || socketWriter == null) return; try { JSONObject response = new JSONObject(); response.put("type", responseType); response.put("data", ""); synchronized (this) { if (socketWriter != null) { socketWriter.write(response.toString()); socketWriter.write("\n\n"); socketWriter.flush(); } } Log.i(TAG, "发送响应: " + responseType); } catch (Exception e) { Log.e(TAG, "发送响应失败", e); } } private void closeSocket(Socket socket) { try { if (socket != null && !socket.isClosed()) { socket.close(); } } catch (IOException e) { Log.w(TAG, "关闭Socket失败", e); } // 如果是当前客户端Socket，重置引用 if (socket == clientSocket) { clientSocket = null; synchronized (this) { socketWriter = null; } sendNetworkMessage("客户端断开连接"); } } private void closeServerSocket() { try { if (serverSocket != null && !serverSocket.isClosed()) { serverSocket.close(); } } catch (IOException e) { Log.w(TAG, "关闭ServerSocket失败", e); } } @Override protected void onDestroy() { super.onDestroy(); isServerRunning = false; // 关闭所有资源 closeServerSocket(); closeSocket(clientSocket); executorService.shutdownNow(); releaseAudioResources(); Log.i(TAG, "应用已销毁"); sendNetworkMessage("服务已停止"); } @Override public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) { super.onRequestPermissionsResult(requestCode, permissions, grantResults); if (requestCode == PERMISSION_REQUEST_CODE) { if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) { Toast.makeText(this, "录音权限已授予", Toast.LENGTH_SHORT).show(); } else { Toast.makeText(this, "录音权限被拒绝", Toast.LENGTH_SHORT).show(); } } } } 怎么把tts的脚本让这个安卓点击开始录音区实现自动转换
07-01
但是，从Android5.0（API21）开始，可以使用SpeechRecognizer.createOnDeviceSpeechRecognizer()进行离线识别（但离线识别支持的语言有限），并且它也不支持从文件识别。因此，我们可能需要使用在线API（如Google...
// 定义包名，对应项目结构中的包路径 package com.example.demoapplication; // 导入Android系统权限相关类 import android.Manifest; // 提供系统权限声明 import android.content.pm.PackageManager; // 用于检查和请求权限 // 导入音频处理相关类 import android.media.AudioFormat; // 音频格式定义 import android.media.AudioManager; // 音频管理器 import android.media.AudioRecord; // 录音功能 import android.media.AudioTrack; // 音频播放功能 import android.media.MediaRecorder; // 媒体录制配置 // 导入Android基础组件类 import android.os.Bundle; // 用于保存和恢复Activity状态 import android.os.Handler; // 用于线程间通信 import android.os.Looper; // 线程消息循环 import android.os.Message; // 消息对象 // 导入语音识别与文本转语音相关类 import android.speech.tts.TextToSpeech; // 文本转语音功能 // 导入数据转换与编码工具类 import android.util.Base64; // Base64编码解码 import android.util.Log; // 日志记录 import android.widget.Button; // 按钮控件 import android.widget.Toast; // 短时提示信息 // 导入AndroidX注解支持 import androidx.annotation.NonNull; // 表示非空注解 // 导入权限兼容处理工具类 import androidx.appcompat.app.AppCompatActivity; // 兼容Activity基类 import androidx.core.app.ActivityCompat; // 兼容权限请求 import androidx.core.content.ContextCompat; // 权限状态检查 // 导入JSON解析库 import org.json.JSONException; // JSON异常 import org.json.JSONObject; // JSON对象操作 // 导入IO流相关类 import java.io.BufferedReader; // 缓冲字符输入流 import java.io.BufferedWriter; // 缓冲字符输出流 import java.io.IOException; // IO异常 import java.io.InputStreamReader; // 字节流到字符流的转换 import java.io.OutputStreamWriter; // 字符流到字节流的转换 // 导入网络通信相关类 import java.net.ServerSocket; // 服务器端Socket import java.net.Socket; // 客户端Socket // 导入集合框架 import java.util.LinkedList; // 双向链表实现 import java.util.Locale; // 地区设置 import java.util.Queue; // 队列接口 // 导入并发编程相关类 import java.util.concurrent.ExecutorService; // 执行服务 import java.util.concurrent.Executors; // 线程池工厂 import java.util.concurrent.ScheduledExecutorService; // 定时任务执行服务 import java.util.concurrent.TimeUnit; // 时间单位 // 导入原子变量类 import java.util.concurrent.atomic.AtomicBoolean; // 原子布尔值 // 主Activity类，继承自AppCompatActivity并实现TTS初始化监听器 public class MainActivity extends AppCompatActivity implements TextToSpeech.OnInitListener { // 日志标签和UI组件定义 private static final String TAG = "AudioRecorder"; // 日志标签 private Button startRecordButton, stopRecordButton; // 录音控制按钮 private AudioRecord audioRecord; // 音频录制实例 // 音频采样率和缓冲区大小配置 private static final int SAMPLE_RATE = 16000; // 采样率（Hz） private static final int BUFFER_SIZE; // 缓冲区大小 // 静态代码块用于初始化缓冲区大小 static { // 计算最小缓冲区大小并确保不小于4096字节 int minBufferSize = AudioRecord.getMinBufferSize( SAMPLE_RATE, AudioFormat.CHANNEL_IN_MONO, AudioFormat.ENCODING_PCM_16BIT ); BUFFER_SIZE = Math.max(minBufferSize, 4096); } // 线程池和服务状态变量 private ScheduledExecutorService scheduler; // 定时任务调度器 private AtomicBoolean isRecording = new AtomicBoolean(false); // 录音状态标志 private static final int PERMISSION_REQUEST_CODE = 1; // 权限请求码 private final ExecutorService executorService = Executors.newCachedThreadPool(); // 缓存线程池 // 网络通信相关变量 private ServerSocket serverSocket; // 服务器Socket private volatile boolean isServerRunning = true; // 服务器运行状态 private volatile Socket clientSocket; // 客户端Socket private volatile BufferedWriter socketWriter; // Socket写入器 // 文字转语音（TTS）引擎和播放器 private TextToSpeech ttsEngine; // TTS引擎实例 private boolean isTtsInitialized = false; // TTS初始化状态 private AudioTrack audioTrack; // 音频播放轨道 // 控制是否已发送开始/结束提示 private boolean isStartMessageSent = false; // 开始消息发送状态 private boolean isStopMessageSent = false; // 停止消息发送状态 private boolean isTransmitStarted = false; // 传输开始状态 private boolean isStopTransmitSent = false; // 停止传输发送状态 // 新增音频播放状态和控制字段 private boolean isPaused = false; // 是否处于暂停状态 private byte[] pausedAudioData; // 暂停时的音频数据 private int pausedPosition; // 暂停位置 // TTS音频队列和播放状态 private final Queue<byte[]> ttsQueue = new LinkedList<>(); // TTS音频队列 private boolean isTtsPlaying = false; // TTS播放状态 // 主线程消息处理器 private final Handler handler = new Handler(Looper.getMainLooper()) { @Override public void handleMessage(@NonNull Message msg) { switch (msg.what) { case 0x11: // 客户端连接 Toast.makeText(MainActivity.this, "客户端已连接", Toast.LENGTH_SHORT).show(); break; case 0x12: // 开始录音 Toast.makeText(MainActivity.this, "开始录音", Toast.LENGTH_SHORT).show(); isStartMessageSent = true; isStopMessageSent = false; sendControlPacket("startRecorder"); playTts("开始录音"); break; case 0x13: // 数据发送 break; case 0x14: // 停止录音 Toast.makeText(MainActivity.this, "停止录音", Toast.LENGTH_SHORT).show(); isStopMessageSent = true; isStartMessageSent = false; sendControlPacket("stopRecorder"); playTts("停止录音"); break; case 0x15: // 控制指令 Toast.makeText(MainActivity.this, "收到指令: " + msg.obj, Toast.LENGTH_SHORT).show(); break; case 0x16: // 错误 Toast.makeText(MainActivity.this, "错误: " + msg.obj, Toast.LENGTH_LONG).show(); break; case 0x18: // TTS音频 handleTtsAudio((String) msg.obj); break; case 0x19: // 聊天开始 Toast.makeText(MainActivity.this, "聊天开始: " + msg.obj, Toast.LENGTH_SHORT).show(); break; case 0x20: // 聊天回复 Toast.makeText(MainActivity.this, "回复: " + msg.obj, Toast.LENGTH_LONG).show(); break; case 0x21: // 播放完成 Toast.makeText(MainActivity.this, "播放完成", Toast.LENGTH_SHORT).show(); // 播放下一段音频 playNextTtsAudio(); break; case 0x22: // 暂停播放 Toast.makeText(MainActivity.this, "播放已暂停", Toast.LENGTH_SHORT).show(); pauseCurrentPlayback(); break; case 0x23: // 继续播放 Toast.makeText(MainActivity.this, "继续播放", Toast.LENGTH_SHORT).show(); resumeCurrentPlayback(); break; case 0x24: // 清除队列 Toast.makeText(MainActivity.this, "队列已清除", Toast.LENGTH_SHORT).show(); clearTtsQueue(); break; } } }; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); // 初始化TTS引擎 ttsEngine = new TextToSpeech(this, this); initViews(); setupClickListeners(); checkPermissions(); startServer(30000); } private void initViews() { startRecordButton = findViewById(R.id.startRecordButton); // 绑定开始录音按钮 stopRecordButton = findViewById(R.id.stopRecordButton); // 绑定停止录音按钮 stopRecordButton.setEnabled(false); // 默认禁用停止按钮 } private void setupClickListeners() { startRecordButton.setOnClickListener(v -> startRecording()); // 设置开始录音点击事件 stopRecordButton.setOnClickListener(v -> stopRecording()); // 设置停止录音点击事件 } private void checkPermissions() { if (ContextCompat.checkSelfPermission(this, Manifest.permission.RECORD_AUDIO) != PackageManager.PERMISSION_GRANTED) { ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.RECORD_AUDIO}, PERMISSION_REQUEST_CODE); } } private void startRecording() { if (ContextCompat.checkSelfPermission(this, Manifest.permission.RECORD_AUDIO) != PackageManager.PERMISSION_GRANTED) { sendErrorMessage("没有录音权限"); return; } if (isRecording.get()) { releaseAudioResources(); } if (clientSocket == null || clientSocket.isClosed() || socketWriter == null) { sendErrorMessage("客户端未连接"); return; } try { audioRecord = new AudioRecord( MediaRecorder.AudioSource.MIC, SAMPLE_RATE, AudioFormat.CHANNEL_IN_MONO, AudioFormat.ENCODING_PCM_16BIT, BUFFER_SIZE ); if (audioRecord.getState() != AudioRecord.STATE_INITIALIZED) { throw new IllegalStateException("AudioRecord 初始化失败"); } audioRecord.startRecording(); isRecording.set(true); startRecordButton.setEnabled(false); stopRecordButton.setEnabled(true); if (scheduler != null) { scheduler.shutdownNow(); } scheduler = Executors.newSingleThreadScheduledExecutor(); scheduler.scheduleAtFixedRate(this::uploadAudioData, 0, 100, TimeUnit.MILLISECONDS); handler.sendEmptyMessage(0x12); sendControlPacket("startRecorder"); playTts("开始录音"); } catch (Exception e) { Log.e(TAG, "录音启动失败", e); sendErrorMessage("录音启动失败: " + e.getMessage()); releaseAudioResources(); } } private void stopRecording() { if (!isRecording.get()) return; isRecording.set(false); releaseAudioResources(); stopRecordButton.setEnabled(false); startRecordButton.setEnabled(true); isStopMessageSent = false; isStartMessageSent = false; handler.sendEmptyMessage(0x14); sendControlPacket("stopRecorder"); playTts("停止录音"); } private void playTts(String text) { if (isTtsInitialized) { ttsEngine.speak(text, TextToSpeech.QUEUE_FLUSH, null); Log.i(TAG, "播放TTS: " + text); } } private void releaseAudioResources() { if (audioRecord != null) { try { if (audioRecord.getRecordingState() == AudioRecord.RECORDSTATE_RECORDING) { audioRecord.stop(); } } catch (IllegalStateException e) { Log.e(TAG, "停止录音失败", e); } audioRecord.release(); audioRecord = null; } if (scheduler != null) { scheduler.shutdownNow(); scheduler = null; } } private void uploadAudioData() { if (!isRecording.get() || clientSocket == null || clientSocket.isClosed() || socketWriter == null) { return; } byte[] buffer = new byte[BUFFER_SIZE]; try { int bytesRead = audioRecord.read(buffer, 0, BUFFER_SIZE); if (bytesRead > 0) { if (audioRecord.getRecordingState() == AudioRecord.RECORDSTATE_RECORDING && !isTransmitStarted) { sendControlPacket("startTransmit"); playTts("开始传输"); audioRecord.startRecording(); isTransmitStarted = true; } if (bytesRead < BUFFER_SIZE / 2 && isTransmitStarted) { sendControlPacket("stopTransmit"); playTts("停止传输"); isTransmitStarted = false; } JSONObject json = new JSONObject(); json.put("type", "recording"); json.put("data", Base64.encodeToString(buffer, 0, bytesRead, Base64.NO_WRAP)); synchronized (this) { if (socketWriter != null) { socketWriter.write(json.toString()); socketWriter.write("\n\n"); socketWriter.flush(); } } } } catch (Exception e) { Log.e(TAG, "发送音频数据失败", e); sendErrorMessage("发送音频数据失败: " + e.getMessage()); } } @Override public void onInit(int status) { if (status == TextToSpeech.SUCCESS) { int result = ttsEngine.setLanguage(Locale.CHINESE); if (result == TextToSpeech.LANG_MISSING_DATA || result == TextToSpeech.LANG_NOT_SUPPORTED) { Log.e(TAG, "TTS语言不支持中文"); } else { isTtsInitialized = true; } } } private void sendControlPacket(String type) { if (clientSocket == null || clientSocket.isClosed() || socketWriter == null) { return; } try { JSONObject packet = new JSONObject(); packet.put("type", type); synchronized (this) { if (socketWriter != null) { socketWriter.write(packet.toString()); socketWriter.write("\n\n"); socketWriter.flush(); } } } catch (Exception e) { Log.e(TAG, "发送控制指令失败", e); } } private void sendErrorMessage(String message) { handler.obtainMessage(0x16, message).sendToTarget(); } private void startServer(int port) { executorService.execute(() -> { try { serverSocket = new ServerSocket(port); Log.i(TAG, "服务器启动: " + port); while (isServerRunning) { try { Socket socket = serverSocket.accept(); clientSocket = socket; synchronized (this) { socketWriter = new BufferedWriter( new OutputStreamWriter(socket.getOutputStream(), "UTF-8")); } handler.sendEmptyMessage(0x11); executorService.execute(() -> startCommunication(socket)); } catch (IOException e) { if (isServerRunning) Log.e(TAG, "接受连接失败", e); } } } catch (IOException e) { Log.e(TAG, "服务器启动失败", e); runOnUiThread(() -> Toast.makeText(this, "服务器启动失败: " + e.getMessage(), Toast.LENGTH_LONG).show()); } finally { closeServerSocket(); } }); } private void startCommunication(Socket socket) { try (BufferedReader reader = new BufferedReader( new InputStreamReader(socket.getInputStream(), "UTF-8"))) { StringBuilder packetBuilder = new StringBuilder(); int c; while ((c = reader.read()) != -1 && isServerRunning) { char ch = (char) c; packetBuilder.append(ch); if (packetBuilder.length() >= 2 && packetBuilder.charAt(packetBuilder.length() - 2) == '\n' && packetBuilder.charAt(packetBuilder.length() - 1) == '\n') { String packet = packetBuilder.toString().trim(); packetBuilder.setLength(0); if (!packet.isEmpty()) { try { JSONObject jsonObject = new JSONObject(packet); handleReceivedPacket(jsonObject); } catch (JSONException e) { Log.w(TAG, "JSON解析失败: " + packet, e); } } } } } catch (IOException e) { if (isServerRunning) { Log.e(TAG, "通信中断", e); } } finally { closeSocket(socket); } } /** * 处理接收到的JSON数据包 * @param jsonObject 接收到的JSON对象 */ private void handleReceivedPacket(JSONObject jsonObject) { try { // 获取数据包类型字段 String type = jsonObject.getString("type"); // 获取可选的数据字段（可能不存在） Object data = jsonObject.opt("data"); Message msg; // 根据数据包类型进行处理 switch (type) { case "tts_audio": // TTS音频数据 // 创建带数据的消息并发送到主线程 msg = handler.obtainMessage(0x18, data.toString()); handler.sendMessage(msg); break; case "chat_start": // 聊天开始事件 // 解析查询内容并发送消息 msg = handler.obtainMessage(0x19, jsonObject.getJSONObject("data").getString("query")); handler.sendMessage(msg); break; case "chat_reply": // 聊天回复事件 // 解析回复内容并发送消息 msg = handler.obtainMessage(0x20, jsonObject.getJSONObject("data").getString("reply")); handler.sendMessage(msg); break; case "play_complete": // 播放完成通知 // 发送空消息触发下一段播放 handler.sendEmptyMessage(0x21); break; case "playSound": // 播放指定音频 // 添加到播放队列 addTtsAudioToQueue(Base64.decode(data.toString(), Base64.DEFAULT)); break; case "pauseSound": // 暂停播放 handler.sendEmptyMessage(0x22); break; case "resumeSound": // 继续播放 handler.sendEmptyMessage(0x23); break; case "stopSound": // 停止播放 handler.sendEmptyMessage(0x24); break; case "clearSound": // 清除队列 // 清空播放队列 handler.sendEmptyMessage(0x24); break; default: // 其他未知类型 // 发送通用处理消息 msg = handler.obtainMessage(0x15, type + ": " + data); handler.sendMessage(msg); break; } } catch (JSONException e) { // 记录JSON处理异常日志 Log.e(TAG, "处理数据包失败", e); } } /** * 处理TTS音频数据 - 将Base64数据解码后加入播放队列 * @param base64Data Base64编码的PCM音频数据 */ private void handleTtsAudio(String base64Data) { // 解码Base64数据为字节数组 byte[] pcmData = Base64.decode(base64Data, Base64.DEFAULT); // 添加到音频播放队列 addTtsAudioToQueue(pcmData); } /** * 将PCM音频数据添加到播放队列 * @param pcmData 要添加的PCM音频数据 */ private void addTtsAudioToQueue(byte[] pcmData) { synchronized (ttsQueue) { // 如果不是暂停状态，则直接加入队列 if (!isPaused) { // 将音频数据加入队列尾部 ttsQueue.offer(pcmData); // 如果当前没有正在播放，则立即开始播放 if (!isTtsPlaying) { playNextTtsAudio(); } } else { // 替换当前暂停的音频数据 pausedAudioData = pcmData; pausedPosition = 0; } } } /** * 播放队列中的下一段音频 */ private void playNextTtsAudio() { synchronized (ttsQueue) { // 如果队列为空，标记播放结束 if (ttsQueue.isEmpty()) { isTtsPlaying = false; return; } // 取出队列头部的音频数据 byte[] pcmData = ttsQueue.poll(); // 开始播放该段音频 playPcm(pcmData); // 标记为正在播放状态 isTtsPlaying = true; } } /** * 播放PCM格式的音频数据，并设置播放完成监听 * @param pcmData PCM音频数据字节数组 */ private void playPcm(byte[] pcmData) { // 停止任何正在进行的音频播放 stopAudioPlayback(); // 设置音频参数 int sampleRate = 16000; // 采样率 int channelConfig = AudioFormat.CHANNEL_OUT_MONO; // 单声道输出 int audioFormat = AudioFormat.ENCODING_PCM_16BIT; // 16位PCM编码 // 计算最小缓冲区大小 int bufferSize = AudioTrack.getMinBufferSize(sampleRate, channelConfig, audioFormat); // 创建音频播放器实例 audioTrack = new AudioTrack( AudioManager.STREAM_MUSIC, // 音频流类型 sampleRate, // 采样率 channelConfig, // 声道配置 audioFormat, // 音频格式 bufferSize, // 缓冲区大小 AudioTrack.MODE_STREAM); // 播放模式 // 设置播放位置监听器 audioTrack.setPlaybackPositionUpdateListener(new AudioTrack.OnPlaybackPositionUpdateListener() { @Override public void onMarkerReached(AudioTrack track) { // 播放完成后发送通知 handler.sendEmptyMessage(0x21); } @Override public void onPeriodicNotification(AudioTrack track) { // 周期性通知，不需要实现 } }); // 计算帧数（单声道，16位，所以每帧2字节） int frameCount = pcmData.length / 2; // 设置标记位置（在最后一帧） audioTrack.setNotificationMarkerPosition(frameCount); audioTrack.play(); audioTrack.write(pcmData, 0, pcmData.length); } // 停止音频播放（添加状态重置） private void stopAudioPlayback() { if (audioTrack != null) { if (audioTrack.getPlayState() == AudioTrack.PLAYSTATE_PLAYING) { audioTrack.stop(); } // 移除监听器，防止回调时使用已释放的对象 audioTrack.setPlaybackPositionUpdateListener(null); audioTrack.release(); audioTrack = null; } // 重置播放状态 synchronized (ttsQueue) { ttsQueue.clear(); isTtsPlaying = false; } } // 暂停当前播放 private void pauseCurrentPlayback() { if (audioTrack != null && audioTrack.getPlayState() == AudioTrack.PLAYSTATE_PLAYING) { audioTrack.pause(); isPaused = true; // 保存当前音频数据和播放位置 if (audioTrack != null && audioTrack.getPlayState() == AudioTrack.PLAYSTATE_PAUSED) { int position = audioTrack.getPlaybackHeadPosition(); if (position > 0) { pausedPosition = position * 2; // 转换为字节位置 if (pausedPosition < audioTrack.getBufferSizeInFrames() * 2) { int remaining = audioTrack.getBufferSizeInFrames() * 2 - pausedPosition; byte[] remainingData = new byte[remaining]; System.arraycopy(pausedAudioData, pausedPosition, remainingData, 0, remaining); pausedAudioData = remainingData; } } } } } // 继续当前播放 private void resumeCurrentPlayback() { if (isPaused && pausedAudioData != null) { // 从暂停位置继续播放 playPcmFromPosition(pausedAudioData, pausedPosition); isPaused = false; } else if (audioTrack != null && audioTrack.getPlayState() == AudioTrack.PLAYSTATE_PAUSED) { audioTrack.play(); } else { // 没有暂停的音频，播放队列中的下一段 playNextTtsAudio(); } } // 从指定位置播放PCM音频数据 private void playPcmFromPosition(byte[] pcmData, int startPosition) { // 停止任何正在进行的音频播放 stopAudioPlayback(); // 设置音频参数 int sampleRate = 16000; // 采样率 int channelConfig = AudioFormat.CHANNEL_OUT_MONO; // 单声道输出 int audioFormat = AudioFormat.ENCODING_PCM_16BIT; // 16位PCM编码 // 计算最小缓冲区大小 int bufferSize = AudioTrack.getMinBufferSize(sampleRate, channelConfig, audioFormat); // 创建音频播放器实例 audioTrack = new AudioTrack( AudioManager.STREAM_MUSIC, // 音频流类型 sampleRate, // 采样率 channelConfig, // 声道配置 audioFormat, // 音频格式 bufferSize, // 缓冲区大小 AudioTrack.MODE_STREAM); // 播放模式 // 设置播放位置监听器 audioTrack.setPlaybackPositionUpdateListener(new AudioTrack.OnPlaybackPositionUpdateListener() { @Override public void onMarkerReached(AudioTrack track) { // 播放完成后发送通知 handler.sendEmptyMessage(0x21); } @Override public void onPeriodicNotification(AudioTrack track) { // 周期性通知，不需要实现 } }); // 计算剩余数据长度 int remainingLength = pcmData.length - startPosition; // 创建新数组存储从指定位置开始的数据 byte[] remainingData = new byte[remainingLength]; System.arraycopy(pcmData, startPosition, remainingData, 0, remainingLength); // 计算帧数（单声道，16位，所以每帧2字节） int frameCount = remainingLength / 2; // 设置标记位置（在最后一帧） audioTrack.setNotificationMarkerPosition(frameCount); audioTrack.play(); audioTrack.write(remainingData, 0, remainingLength); } // 清空TTS播放队列 private void clearTtsQueue() { synchronized (ttsQueue) { ttsQueue.clear(); // 停止当前播放并重置状态 if (audioTrack != null) { if (audioTrack.getPlayState() == AudioTrack.PLAYSTATE_PLAYING) { audioTrack.stop(); } audioTrack.release(); audioTrack = null; } isTtsPlaying = false; isPaused = false; pausedAudioData = null; pausedPosition = 0; } } private void closeSocket(Socket socket) { try { if (socket != null && !socket.isClosed()) { socket.close(); } } catch (IOException e) { Log.w(TAG, "关闭Socket失败", e); } if (socket == clientSocket) { clientSocket = null; synchronized (this) { socketWriter = null; } } } private void closeServerSocket() { try { if (serverSocket != null && !serverSocket.isClosed()) { serverSocket.close(); } } catch (IOException e) { Log.w(TAG, "关闭ServerSocket失败", e); } } @Override protected void onDestroy() { super.onDestroy(); isServerRunning = false; if (ttsEngine != null) { ttsEngine.stop(); ttsEngine.shutdown(); } closeServerSocket(); closeSocket(clientSocket); executorService.shutdownNow(); releaseAudioResources(); stopAudioPlayback(); } @Override public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) { super.onRequestPermissionsResult(requestCode, permissions, grantResults); if (requestCode == PERMISSION_REQUEST_CODE) { if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) { Toast.makeText(this, "录音权限已授予", Toast.LENGTH_SHORT).show(); } else { Toast.makeText(this, "录音权限被拒绝", Toast.LENGTH_SHORT).show(); } } } public boolean isStopTransmitSent() { return isStopTransmitSent; } public void setStopTransmitSent(boolean stopTransmitSent) { isStopTransmitSent = stopTransmitSent; } public boolean isStartMessageSent() { return isStartMessageSent; } public void setStartMessageSent(boolean startMessageSent) { isStartMessageSent = startMessageSent; } public boolean isStopMessageSent() { return isStopMessageSent; } public void setStopMessageSent(boolean stopMessageSent) { isStopMessageSent = stopMessageSent; } } 生成能接收的后台java代码
07-03
private volatile BufferedWriter socketWriter; private volatile boolean isServerRunning = true; private final ExecutorService executor = Executors.newCachedThreadPool(); // TTS播放状态 private ...
package com.example.demoapplication; import android.Manifest; import android.content.pm.PackageManager; import android.media.AudioFormat; import android.media.AudioRecord; import android.media.AudioTrack; import android.media.MediaRecorder; import android.os.Bundle; import android.os.Handler; import android.os.Looper; import android.os.Message; import android.speech.tts.TextToSpeech; import android.util.Base64; import android.util.Log; import android.widget.Button; import android.widget.Toast; import androidx.annotation.NonNull; import androidx.appcompat.app.AppCompatActivity; import androidx.core.app.ActivityCompat; import androidx.core.content.ContextCompat; import org.json.JSONException; import org.json.JSONObject; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.IOException; import java.io.OutputStreamWriter; import java.io.InputStreamReader; import java.net.ServerSocket; import java.net.Socket; import java.util.Locale; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicBoolean; public class MainActivity extends AppCompatActivity implements TextToSpeech.OnInitListener { // 日志标签和UI组件定义 private static final String TAG = "AudioRecorder"; private Button startRecordButton, stopRecordButton; private AudioRecord audioRecord; // 音频采样率和缓冲区大小配置 private static final int SAMPLE_RATE = 16000; private static final int BUFFER_SIZE; static { // 计算最小缓冲区大小并确保不小于4096字节 int minBufferSize = AudioRecord.getMinBufferSize( SAMPLE_RATE, AudioFormat.CHANNEL_IN_MONO, AudioFormat.ENCODING_PCM_16BIT ); BUFFER_SIZE = Math.max(minBufferSize, 4096); } // 线程池和服务状态变量 private ScheduledExecutorService scheduler; private AtomicBoolean isRecording = new AtomicBoolean(false); private static final int PERMISSION_REQUEST_CODE = 1; private final ExecutorService executorService = Executors.newCachedThreadPool(); // 网络通信相关变量 private ServerSocket serverSocket; private volatile boolean isServerRunning = true; private volatile Socket clientSocket; private volatile BufferedWriter socketWriter; // 文字转语音（TTS）引擎和播放器 private TextToSpeech ttsEngine; private boolean isTtsInitialized = false; private AudioTrack audioTrack; // 控制是否已发送开始/结束提示 private boolean isStartMessageSent = false; private boolean isStopMessageSent = false; private boolean isTransmitStarted = false; // 新增标志位控制startTransmit只显示一次 private boolean isStopTransmitSent = false; // 新增标志位控制stopTransmit只显示一次 // 主线程消息处理器 private final Handler handler = new Handler(Looper.getMainLooper()) { @Override public void handleMessage(@NonNull Message msg) { switch (msg.what) { case 0x11: // 客户端连接 Toast.makeText(MainActivity.this, "客户端已连接", Toast.LENGTH_SHORT).show(); break; case 0x12: // 开始录音 if (!isStartMessageSent) { Toast.makeText(MainActivity.this, "开始录音", Toast.LENGTH_SHORT).show(); isStartMessageSent = true; isStopMessageSent = false; } sendControlPacket("startRecorder"); // 发送开始录音指令给客户端 playTts("开始录音"); // 触发TTS播报"开始录音" break; case 0x13: // 数据发送 break; case 0x14: // 停止录音 if (!isStopMessageSent) { Toast.makeText(MainActivity.this, "停止录音", Toast.LENGTH_SHORT).show(); isStopMessageSent = true; isStartMessageSent = false; } sendControlPacket("stopRecorder"); // 发送停止录音指令给客户端 playTts("停止录音"); // 触发TTS播报"停止录音" break; case 0x15: // 控制指令 Toast.makeText(MainActivity.this, "收到指令: " + msg.obj, Toast.LENGTH_SHORT).show(); break; case 0x16: // 错误 Toast.makeText(MainActivity.this, "错误: " + msg.obj, Toast.LENGTH_LONG).show(); break; case 0x18: // TTS音频 handleTtsAudio((String) msg.obj); break; case 0x19: // 聊天开始 Toast.makeText(MainActivity.this, "聊天开始: " + msg.obj, Toast.LENGTH_SHORT).show(); break; case 0x20: // 聊天回复 Toast.makeText(MainActivity.this, "回复: " + msg.obj, Toast.LENGTH_LONG).show(); break; case 0x21: // 播放完成 Toast.makeText(MainActivity.this, "播放完成", Toast.LENGTH_SHORT).show(); break; } } }; // Activity生命周期方法 @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); // 初始化TTS引擎 ttsEngine = new TextToSpeech(this, this); initViews(); setupClickListeners(); checkPermissions(); startServer(30000); } // 初始化视图控件 private void initViews() { startRecordButton = findViewById(R.id.startRecordButton); stopRecordButton = findViewById(R.id.stopRecordButton); stopRecordButton.setEnabled(false); } // 设置按钮点击事件监听器 private void setupClickListeners() { startRecordButton.setOnClickListener(v -> startRecording()); stopRecordButton.setOnClickListener(v -> stopRecording()); } // 检查录音权限 private void checkPermissions() { if (ContextCompat.checkSelfPermission(this, Manifest.permission.RECORD_AUDIO) != PackageManager.PERMISSION_GRANTED) { ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.RECORD_AUDIO}, PERMISSION_REQUEST_CODE); } } // 开始录音操作 private void startRecording() { if (ContextCompat.checkSelfPermission(this, Manifest.permission.RECORD_AUDIO) != PackageManager.PERMISSION_GRANTED) { sendErrorMessage("没有录音权限"); return; } if (isRecording.get()) { // 允许重复启动：如果已经在录音，先释放资源 releaseAudioResources(); } if (clientSocket == null || clientSocket.isClosed() || socketWriter == null) { sendErrorMessage("客户端未连接"); return; } try { // 创建并初始化AudioRecord对象 audioRecord = new AudioRecord( MediaRecorder.AudioSource.MIC, SAMPLE_RATE, AudioFormat.CHANNEL_IN_MONO, AudioFormat.ENCODING_PCM_16BIT, BUFFER_SIZE ); if (audioRecord.getState() != AudioRecord.STATE_INITIALIZED) { throw new IllegalStateException("AudioRecord 初始化失败"); } // 启动录音，更新UI状态，启动定时上传任务 audioRecord.startRecording(); isRecording.set(true); startRecordButton.setEnabled(false); stopRecordButton.setEnabled(true); // 如果已有调度器，先关闭再新建 if (scheduler != null) { scheduler.shutdownNow(); } scheduler = Executors.newSingleThreadScheduledExecutor(); scheduler.scheduleAtFixedRate(this::uploadAudioData, 0, 100, TimeUnit.MILLISECONDS); handler.sendEmptyMessage(0x12); sendControlPacket("startRecorder"); playTts("开始录音"); } catch (Exception e) { Log.e(TAG, "录音启动失败", e); sendErrorMessage("录音启动失败: " + e.getMessage()); releaseAudioResources(); } } // 停止录音操作 private void stopRecording() { if (!isRecording.get()) return; isRecording.set(false); releaseAudioResources(); stopRecordButton.setEnabled(false); startRecordButton.setEnabled(true); // 允许再次开始录音 handler.sendEmptyMessage(0x14); sendControlPacket("stopRecorder"); playTts("停止录音"); } // 播放TTS语音 private void playTts(String text) { if (isTtsInitialized) { ttsEngine.speak(text, TextToSpeech.QUEUE_FLUSH, null); Log.i(TAG, "播放TTS: " + text); } } // 释放录音资源 private void releaseAudioResources() { if (audioRecord != null) { try { if (audioRecord.getRecordingState() == AudioRecord.RECORDSTATE_RECORDING) { audioRecord.stop(); } } catch (IllegalStateException e) { Log.e(TAG, "停止录音失败", e); } audioRecord.release(); audioRecord = null; } if (scheduler != null) { scheduler.shutdownNow(); scheduler = null; } } // 上传音频数据到服务器 private void uploadAudioData() { if (!isRecording.get() || clientSocket == null || clientSocket.isClosed() || socketWriter == null) { return; } byte[] buffer = new byte[BUFFER_SIZE]; try { int bytesRead = audioRecord.read(buffer, 0, BUFFER_SIZE); if (bytesRead > 0) { // 首次读取数据时发送开始指令，并且仅发送一次 if (audioRecord.getRecordingState() == AudioRecord.RECORDSTATE_RECORDING && !isTransmitStarted) { sendControlPacket("startTransmit"); // 发送开始传输指令 playTts("开始传输"); // 触发TTS播报"开始传输" audioRecord.startRecording(); // 确保录音已开始 isTransmitStarted = true; // 标记为已发送 } // 在最后一次读取数据后发送停止传输指令 if (bytesRead < BUFFER_SIZE / 2 && isTransmitStarted) { sendControlPacket("stopTransmit"); // 发送停止传输指令 playTts("停止传输"); // 触发TTS播报"停止传输" isTransmitStarted = false; // 重置标志位以便下次使用 } JSONObject json = new JSONObject(); json.put("type", "recording"); json.put("data", Base64.encodeToString(buffer, 0, bytesRead, Base64.NO_WRAP)); synchronized (this) { if (socketWriter != null) { socketWriter.write(json.toString()); socketWriter.write("\n\n"); socketWriter.flush(); } } } } catch (Exception e) { Log.e(TAG, "发送音频数据失败", e); sendErrorMessage("发送音频数据失败: " + e.getMessage()); } } // TTS初始化回调 @Override public void onInit(int status) { if (status == TextToSpeech.SUCCESS) { int result = ttsEngine.setLanguage(Locale.CHINESE); if (result == TextToSpeech.LANG_MISSING_DATA || result == TextToSpeech.LANG_NOT_SUPPORTED) { Log.e(TAG, "TTS语言不支持中文"); } else { isTtsInitialized = true; } } } // 发送控制指令包 private void sendControlPacket(String type) { if (clientSocket == null || clientSocket.isClosed() || socketWriter == null) { return; } try { JSONObject packet = new JSONObject(); packet.put("type", type); synchronized (this) { if (socketWriter != null) { socketWriter.write(packet.toString()); socketWriter.write("\n\n"); socketWriter.flush(); } } } catch (Exception e) { Log.e(TAG, "发送控制指令失败", e); } } // 发送错误信息到主线程 private void sendErrorMessage(String message) { handler.obtainMessage(0x16, message).sendToTarget(); } // 启动TCP服务器 private void startServer(int port) { executorService.execute(() -> { try { serverSocket = new ServerSocket(port); Log.i(TAG, "服务器启动: " + port); while (isServerRunning) { try { Socket socket = serverSocket.accept(); clientSocket = socket; synchronized (this) { socketWriter = new BufferedWriter( new OutputStreamWriter(socket.getOutputStream(), "UTF-8")); } handler.sendEmptyMessage(0x11); executorService.execute(() -> startCommunication(socket)); } catch (IOException e) { if (isServerRunning) Log.e(TAG, "接受连接失败", e); } } } catch (IOException e) { Log.e(TAG, "服务器启动失败", e); runOnUiThread(() -> Toast.makeText(this, "服务器启动失败: " + e.getMessage(), Toast.LENGTH_LONG).show()); } finally { closeServerSocket(); } }); } // 处理客户端通信 private void startCommunication(Socket socket) { try (BufferedReader reader = new BufferedReader( new InputStreamReader(socket.getInputStream(), "UTF-8"))) { StringBuilder packetBuilder = new StringBuilder(); int c; while ((c = reader.read()) != -1 && isServerRunning) { char ch = (char) c; packetBuilder.append(ch); if (packetBuilder.length() >= 2 && packetBuilder.charAt(packetBuilder.length() - 2) == '\n' && packetBuilder.charAt(packetBuilder.length() - 1) == '\n') { String packet = packetBuilder.toString().trim(); packetBuilder.setLength(0); if (!packet.isEmpty()) { try { JSONObject jsonObject = new JSONObject(packet); handleReceivedPacket(jsonObject); } catch (JSONException e) { Log.w(TAG, "JSON解析失败: " + packet, e); } } } } } catch (IOException e) { if (isServerRunning) { Log.e(TAG, "通信中断", e); } } finally { closeSocket(socket); } } // 处理接收到的数据包 private void handleReceivedPacket(JSONObject jsonObject) { try { String type = jsonObject.getString("type"); Object data = jsonObject.opt("data"); Message msg; switch (type) { case "tts_audio": msg = handler.obtainMessage(0x18, data.toString()); handler.sendMessage(msg); break; case "chat_start": msg = handler.obtainMessage(0x19, jsonObject.getJSONObject("data").getString("query")); handler.sendMessage(msg); break; case "chat_reply": msg = handler.obtainMessage(0x20, jsonObject.getJSONObject("data").getString("reply")); handler.sendMessage(msg); break; case "play_complete": handler.sendEmptyMessage(0x21); break; default: msg = handler.obtainMessage(0x15, type + ": " + data); handler.sendMessage(msg); break; } } catch (JSONException e) { Log.e(TAG, "处理数据包失败", e); } } // 处理TTS音频数据 private void handleTtsAudio(String base64Data) { byte[] pcmData = Base64.decode(base64Data, Base64.DEFAULT); playPcm(pcmData); } // 播放PCM音频 private void playPcm(byte[] pcmData) { stopAudioPlayback(); int sampleRate = 16000; int channelConfig = AudioFormat.CHANNEL_OUT_MONO; int audioFormat = AudioFormat.ENCODING_PCM_16BIT; int bufferSize = AudioTrack.getMinBufferSize(sampleRate, channelConfig, audioFormat); audioTrack = new AudioTrack( android.media.AudioManager.STREAM_MUSIC, sampleRate, channelConfig, audioFormat, bufferSize, AudioTrack.MODE_STREAM); audioTrack.play(); audioTrack.write(pcmData, 0, pcmData.length); } // 停止音频播放 private void stopAudioPlayback() { if (audioTrack != null) { if (audioTrack.getPlayState() == AudioTrack.PLAYSTATE_PLAYING) { audioTrack.stop(); } audioTrack.release(); audioTrack = null; } } // 关闭指定的Socket连接 private void closeSocket(Socket socket) { try { if (socket != null && !socket.isClosed()) { socket.close(); } } catch (IOException e) { Log.w(TAG, "关闭Socket失败", e); } if (socket == clientSocket) { clientSocket = null; synchronized (this) { socketWriter = null; } } } // 关闭服务器Socket private void closeServerSocket() { try { if (serverSocket != null && !serverSocket.isClosed()) { serverSocket.close(); } } catch (IOException e) { Log.w(TAG, "关闭ServerSocket失败", e); } } // Activity销毁时清理资源 @Override protected void onDestroy() { super.onDestroy(); isServerRunning = false; if (ttsEngine != null) { ttsEngine.stop(); ttsEngine.shutdown(); } closeServerSocket(); closeSocket(clientSocket); executorService.shutdownNow(); releaseAudioResources(); stopAudioPlayback(); } // 权限请求结果处理 @Override public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) { super.onRequestPermissionsResult(requestCode, permissions, grantResults); if (requestCode == PERMISSION_REQUEST_CODE) { if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) { Toast.makeText(this, "录音权限已授予", Toast.LENGTH_SHORT).show(); } else { Toast.makeText(this, "录音权限被拒绝", Toast.LENGTH_SHORT).show(); } } } public boolean isStopTransmitSent() { return isStopTransmitSent; } public void setStopTransmitSent(boolean stopTransmitSent) { isStopTransmitSent = stopTransmitSent; } } 用这个安卓代码生成一个可以接受的脚本
07-02
根据提供的Android代码，这是一个实现音频录制、网络传输和TTS（文本转语音）的应用程序。主要功能包括：1.启动TCP服务器（端口30000）等待客户端连接。2.客户端连接后，可以开始录音，将录音数据实时通过Socket发送...
import socket import subprocess import websocket import time import os import threading import json import pyaudio import requests import hashlib import base64 from audioplayer import AudioPlayer import numpy as np from runner import set_global_var, get_global_var device_status = {} def listen_devices(): try: # 检测设备连接状态 result = subprocess.check_output("adb devices", shell=True).decode() current_devices = set(line.split('\t')[0] for line in result.splitlines()[1:] if line) # 检测新连接设备 for dev in current_devices - set(device_status.keys()): print(f"[设备已连接] {dev}") device_status[dev] = "connected" # 检测断开设备 for dev in set(device_status.keys()) - current_devices: print(f"[设备已断开连接] {dev}") del device_status[dev] time.sleep(1) except Exception as e: print(f"设备监控错误： {e}") def pcm_to_utf8(pcm_data: bytearray) -> str: """将16位PCM音频数据转为UTF-8字符串""" def validate_pcm(data: bytearray) -> bool: """验证PCM数据有效性""" return len(data) % 2 == 0 # 16位PCM需为偶数长度 if not validate_pcm(pcm_data): raise ValueError("无效的PCM数据长度，16位PCM需为偶数长度") try: # 转为16位有符号整数数组(小端序) samples = np.frombuffer(pcm_data, dtype='<i2') # 标准化到0-255范围 normalized = ((samples - samples.min()) * (255 / (samples.max() - samples.min()))).astype(np.uint8) # 转换为UTF-8字符串 return bytes(normalized).decode('utf-8', errors='replace') except Exception as e: raise RuntimeError(f"转换失败: {str(e)}") # 打印前32字节的十六进制表示 def parse_packets(buffer): """解析接收到的数据包""" # 解析数据包 end_marker = b'\n\n' while buffer.find(end_marker) != -1: packet_bytes = buffer[:buffer.find(end_marker) + len(end_marker)] buffer = buffer[buffer.find(end_marker) + len(end_marker):] try: json_bytes = packet_bytes[:-len(end_marker)] json_str = json_bytes.decode('utf-8') packet = json.loads(json_str) # 处理数据包 packet_type = packet.get("type") if packet_type == "recording": audio_data = base64.b64decode(packet.get("data", "")) print('audio_data ', audio_data) return audio_data elif packet_type in ["startRecorder", "stopRecord"]: pass # command_callback(packet_type) else: print(f"未知数据包类型: {packet_type}") except json.JSONDecodeError as e: print(f"JSON解析错误: {e}") except Exception as e: print(f"数据包处理错误: {e}") def start_server(port=35000): adb_path = "adb.exe" os.system(f"adb forward tcp:{port} tcp:30000") with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.connect(('localhost', port)) #s.bind(('0.0.0.0', port)) #s.listen(5) print(f"服务器已启动，正在监听端口 {port}...") while True: threading.Thread(target=listen_devices).start() #client_socket, addr = s.accept() #print(f"接收到来自 {addr} 的连接") buffer = bytearray() try: while True: data = s.recv(4096) if data == b'': pass else: print('data', data) #buffer.extend(data) if not data: print("连接断开") break buffer.extend(data) hex_preview = parse_packets(buffer) handle_audio_chunk(hex_preview) print('hex_preview',hex_preview) '''if data==b'': pass else: if len(data) > 0: hex_preview = ' '.join(f'{b:02x}' for b in data[:32]) print(f"前32字节: {hex_preview}...") #handle_audio_chunk(hex_preview) # 调试用：将PCM转为UTF-8 if len(data) < 1024: try: utf8_data = pcm_to_utf8(data) print(f"UTF-8预览: {utf8_data[:30]}...") #handle_audio_chunk(utf8_data) except: pass''' except Exception as e: print(f"接收音频数据异常: {e}") # 全局配置信息 # 播放时是否停止收音 stop_recording_when_playing = True # 打断播放的语音指令 stop_playing_words = ["别说了", "停止", "停下"] # 说话人id voice_speaker_id = 5199 # 语音活动检测-静音时间长度，超过这个时间视为停止说话 vad_silent_time = 1.5 # 语音合成参数 tts_params = {"lan": "zh", "cuid": "test-1234", "ctp": 1, "pdt":993, "spd":5, "pit": 5,"aue": 3} # 语音识别开始指令参数 asr_params = { "type": "START", "data": { "dev_pid": 1912, "dev_key": "com.baidu.open", "format": "pcm", "sample": 16000, "cuid": "my_test_dev", "type": 1, "asr_type": 1, "need_mid": False, "need_session_finish": True } } # 全局状态变量 ws_running = False ws_object = None recorder_running = False sound_play_list = [] current_audio_player = None chat_running = False current_query = '' last_asr_time = 0 def ws_send_start_command(ws): message = json.dumps(asr_params) ws.send_text(message) def ws_send_stop_command(ws): # 发送数据 msg_data = { "type": "FINISH", } message = json.dumps(msg_data) ws.send_text(message) def on_ws_message(ws, message): global current_query, last_asr_time data = json.loads(message) cmd_type = data.get("type") if cmd_type == 'MID_TEXT': mid_text = data.get("result") set_global_var("voicebot.asr.mid_text", mid_text) last_asr_time = time.time() # print("voicebot.asr.mid_text:", mid_text) elif cmd_type == "FIN_TEXT": query = data.get("result") # print("asr result:", query) set_global_var("voicebot.asr.result", query) last_asr_time = time.time() if query and len(query) > 0: current_query += query set_global_var("voicebot.chat.query", current_query) if ws_running == False: ws.close() def on_ws_close(ws, close_status_code, close_msg): print("websocket closed:", close_status_code, close_msg) def on_ws_error(ws, error): print(f"websocket Error: {error}") ws.close() def on_ws_open(ws): print("websocket connection opened:", ws) ws_send_start_command(ws) def check_chat(query:str): # for word in stop_playing_words: # if word in query: # stop_sound_player() # return False # if query in stop_playing_words: # stop_sound_player() # return False if is_playing_or_chatting(): return False return True def stop_sound_player(): global chat_running if current_audio_player: current_audio_player.stop() if len(sound_play_list) > 0: sound_play_list.clear() chat_running = False def run_chat(query:str): global chat_running chat_running = True set_global_var("voicebot.chat.query", query) params = {"query": query} params['username'] = get_global_var("voicebot.username") params['password'] = get_global_var("voicebot.password") response = requests.post("http://127.0.0.1:8010/chat", json=params, stream=True) total_reply = '' buffer = '' for line in response.iter_lines(): if line and chat_running: text = line.decode('utf-8') data = json.loads(text[5:]) content = data.get("content") buffer += content buffer = extract_play_text(buffer) total_reply += content set_global_var("voicebot.chat.reply", total_reply) # print(content, end='', flush=True) chat_running = False buffer = buffer.strip() if len(buffer) > 0: add_play_text(buffer) time.sleep(1) set_global_var("voicebot.chat.query", None) set_global_var("voicebot.chat.reply", None) #提取播放文本 def extract_play_text(total_text:str): separators = "，；。！？：,.!?\n" last_start_pos = 0 min_sentence_length = 4 for i in range(0, len(total_text)): if total_text[i] in separators and i - last_start_pos >= min_sentence_length: text = total_text[last_start_pos: i + 1] last_start_pos = i + 1 add_play_text(text.strip()) return total_text[last_start_pos:] #添加播放文本 def add_play_text(text:str): # print("add play text:", text) if len(text) > 1: sound_play_list.append({"text": text, "mp3_file": None}) # 语音合成 下载声音文件 def download_sound_file(text:str, speaker:int=None): if speaker is None: speaker = voice_speaker_id # print("tts create:", text) mp3_path = "sounds/" + str(speaker) if not os.path.exists(mp3_path): os.mkdir(mp3_path) mp3_file = mp3_path + "/" + hashlib.md5(text.encode('utf-8')).hexdigest() + ".mp3" if os.path.exists(mp3_file): return mp3_file params = tts_params params['per'] = speaker params['text'] = text url = "http://25.83.75.1:8088/Others/tts/text2audio/json" response = requests.post(url, json=params) data = response.json() if data['success'] == False: binary_array = json.loads(data['message']['message']) binary_data = bytes(binary_array) string_data = binary_data.decode('utf-8', errors='replace') data = json.loads(string_data) return "sounds/tts-failed.mp3" else: b64_string = data['result'].get('data') mp3_data = base64.b64decode(b64_string) with open(mp3_file, 'wb') as file: file.write(mp3_data) return mp3_file #开始聊天 def is_playing_or_chatting(): return len(sound_play_list) > 0 #播放下一个声音 def play_next_sound(): global sound_play_list, current_audio_player item = sound_play_list[0] mp3_file = item.get("mp3_file") if mp3_file: player = AudioPlayer(mp3_file) current_audio_player = player try: player.play(block=True) except Exception as e: print("player exception:" + e) current_audio_player = None # print("remained sound:", len(sound_play_list)) if len(sound_play_list) > 0: sound_play_list.pop(0) #运行websocket def run_websocket(): global ws_running, ws_object ws_running = True uri = "ws://25.83.75.1:8088/Others/asr/realtime_asr?sn=voicebot" ws = websocket.WebSocketApp(uri, on_message=on_ws_message, on_close=on_ws_close, on_error=on_ws_error) ws_object = ws ws.on_open = on_ws_open ws.run_forever() ws_running = False # print("websocket end") #开始记录 def start_recorder(chuck_size:int=2560): audio = pyaudio.PyAudio() try: stream = audio.open(format=pyaudio.paInt16, channels=1, rate=16000, input=True, frames_per_buffer=chuck_size) return audio, stream except: print("打开麦克风失败") return None, None #获得不发音的时间 def get_silent_chunk(duration:float=0.16): sample_rate = 16000 # 采样率 num_samples = int(sample_rate * duration) # 计算样本数 silent_data = np.zeros(num_samples, dtype=np.int16) silent_bytes = silent_data.tobytes() return silent_bytes #处理音频块 def handle_audio_chunk(chunk_data:bytes): # 接受外部是否收音的要求 recording = get_global_var("voicebot.recording") if ws_object and ws_object.sock and ws_object.sock.connected: if recording == False or (stop_recording_when_playing and is_playing_or_chatting()): # print("ignor audio chunk:", sound_play_list, chat_running) ws_object.send_bytes(get_silent_chunk()) else: ws_object.send_bytes(chunk_data) #运行录音机 def run_recorder(audio=None, stream=None, chuck_size=2560): global recorder_running recorder_running = True set_global_var("voicebot.recording", True) while recorder_running: chunk_data = stream.read(chuck_size) print('chunk_data)',chunk_data) handle_audio_chunk(chunk_data) stream.stop_stream() stream.close() audio.terminate() # print("recorder end") #运行检查 def run_check(): global ws_running, recorder_running, current_query set_global_var("voicebot.running", True) while ws_running and recorder_running: time.sleep(1) if get_global_var("voicebot.running") == False: break if len(current_query) > 0 and last_asr_time > 0 and time.time() - last_asr_time > vad_silent_time: t = threading.Thread(target=run_chat, args=(current_query,)) t.start() current_query = '' ws_running = recorder_running = False set_global_var("voicebot.running", False) # print("语音助手已经停止") #运行播放机 def run_player(): while ws_running and recorder_running: time.sleep(0.1) if len(sound_play_list) > 0: play_next_sound() def run_tts(): while ws_running and recorder_running: time.sleep(0.1) for item in sound_play_list: if item.get("mp3_file") is None: item['mp3_file'] = download_sound_file(item['text']) def run(): active_threads = threading.enumerate() # 打印每个活跃线程的信息 for t in active_threads: if t.name == 'voicebot-runner': return "语音助手已经在运行中了" audio, stream = start_recorder() if audio is None or stream is None: return {"error": "语音助手开启失败，无法访问麦克风"} t = threading.Thread(target=run_websocket) t.daemon = True t.start() t=threading.Thread(target=start_server()) t.daemon = True t.start() t = threading.Thread(target=run_check, name='voicebot-runner') t.daemon = True t.start() t = threading.Thread(target=run_tts) t.daemon = True t.start() t = threading.Thread(target=run_player) t.daemon = True t.start() return "执行成功" if __name__ == "__main__": #run() start_server() 把这个TTS的功能融入到第一个脚本里面生成新脚本，并且修改安卓的代码package com.example.demoapplication; import android.Manifest; import android.content.pm.PackageManager; import android.media.AudioFormat; import android.media.AudioRecord; import android.media.MediaRecorder; import android.os.Build; import android.os.Bundle; import android.os.Handler; import android.os.Looper; import android.os.Message; import android.speech.tts.TextToSpeech; import android.util.Base64; import android.util.Log; import android.widget.Button; import android.widget.Toast; import androidx.annotation.NonNull; import androidx.appcompat.app.AppCompatActivity; import androidx.core.app.ActivityCompat; import androidx.core.content.ContextCompat; import org.json.JSONException; import org.json.JSONObject; import java.io.BufferedWriter; import java.io.IOException; import java.io.OutputStreamWriter; import java.net.ServerSocket; import java.net.Socket; import java.util.Locale; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicBoolean; public class MainActivity extends AppCompatActivity implements TextToSpeech.OnInitListener { private static final String TAG = "AudioRecorder"; private Button startRecordButton; private Button stopRecordButton; private Button uploadButton; // 音频录制相关 private AudioRecord audioRecord; private static final int SAMPLE_RATE = 44100; // 音频采样率 private static final int BUFFER_SIZE; // 静态代码块用于初始化缓冲区大小 static { int minBufferSize = 0; if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.CUPCAKE) { minBufferSize = AudioRecord.getMinBufferSize( SAMPLE_RATE, AudioFormat.CHANNEL_IN_MONO, AudioFormat.ENCODING_PCM_16BIT ); } // 确保缓冲区大小有效 BUFFER_SIZE = Math.max(minBufferSize, 4096); } // 多线程任务调度器 private ScheduledExecutorService scheduler; private AtomicBoolean isRecording = new AtomicBoolean(false); // 录音状态标志 private static final int PERMISSION_REQUEST_CODE = 1; // 权限请求码 // 线程池服务 private final ExecutorService executorService = Executors.newCachedThreadPool(); // 网络服务器相关 private ServerSocket serverSocket; private volatile boolean isServerRunning = true; // 服务器运行状态 private volatile Socket clientSocket; // 客户端Socket连接 private volatile BufferedWriter socketWriter; // Socket写入流 // 文本转语音(TTS)相关变量 private TextToSpeech ttsEngine; private boolean isTtsInitialized = false; // 主线程消息处理器，用于UI更新 private final Handler handler = new Handler(Looper.getMainLooper()) { @Override public void handleMessage(@NonNull Message msg) { switch (msg.what) { case 0x11: // 客户端连接成功 Toast.makeText(MainActivity.this, "客户端已连接", Toast.LENGTH_SHORT).show(); break; case 0x12: // 开始录音 Toast.makeText(MainActivity.this, "开始录音", Toast.LENGTH_SHORT).show(); break; case 0x13: // 数据发送成功 // 减少Toast频率，避免刷屏 if (Math.random() < 0.1) { // 10%概率显示 Toast.makeText(MainActivity.this, "录音数据已发送", Toast.LENGTH_SHORT).show(); } break; case 0x14: // 停止录音 Toast.makeText(MainActivity.this, "停止录音", Toast.LENGTH_SHORT).show(); break; case 0x15: // 控制指令 Toast.makeText(MainActivity.this, "收到控制指令：" + msg.obj.toString(), Toast.LENGTH_SHORT).show(); break; case 0x16: // 错误消息 Toast.makeText(MainActivity.this, "错误: " + msg.obj.toString(), Toast.LENGTH_LONG).show(); break; case 0x17: // 网络状态 Toast.makeText(MainActivity.this, "网络: " + msg.obj.toString(), Toast.LENGTH_SHORT).show(); break; } } }; /** * Activity创建时调用，进行初始化操作。 * @param savedInstanceState 保存的状态数据 */ @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); // 初始化TTS引擎 ttsEngine = new TextToSpeech(this, this); initViews(); // 初始化视图组件 setupClickListeners(); // 设置点击事件监听器 checkPermissions(); // 检查权限 startServer(30000); // 启动服务器，端口30000 } /** * 初始化UI视图组件 */ private void initViews() { startRecordButton = findViewById(R.id.startRecordButton); stopRecordButton = findViewById(R.id.stopRecordButton); uploadButton = findViewById(R.id.uploadButton); stopRecordButton.setEnabled(false); uploadButton.setEnabled(false); } /** * 设置按钮点击事件监听器 */ private void setupClickListeners() { startRecordButton.setOnClickListener(v -> startRecording()); stopRecordButton.setOnClickListener(v -> stopRecording()); uploadButton.setOnClickListener(v -> uploadRecording()); } /** * 检查录音权限并请求必要权限 */ private void checkPermissions() { if (ContextCompat.checkSelfPermission(this, Manifest.permission.RECORD_AUDIO) != PackageManager.PERMISSION_GRANTED) { ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.RECORD_AUDIO}, PERMISSION_REQUEST_CODE); } } /** * 开始录音操作 */ private void startRecording() { // 检查权限 if (ContextCompat.checkSelfPermission(this, Manifest.permission.RECORD_AUDIO) != PackageManager.PERMISSION_GRANTED) { sendErrorMessage("没有录音权限"); return; } // 检查是否正在录音 if (isRecording.get() || audioRecord != null) { sendErrorMessage("录音已在进行中"); return; } // 检查网络连接 if (clientSocket == null || clientSocket.isClosed() || socketWriter == null) { sendErrorMessage("客户端未连接，无法录音"); return; } try { // 初始化 AudioRecord audioRecord = new AudioRecord( MediaRecorder.AudioSource.MIC, SAMPLE_RATE, AudioFormat.CHANNEL_IN_MONO, AudioFormat.ENCODING_PCM_16BIT, BUFFER_SIZE ); // 检查初始化状态 if (audioRecord.getState() != AudioRecord.STATE_INITIALIZED) { throw new IllegalStateException("AudioRecord 初始化失败"); } // 开始录音 audioRecord.startRecording(); isRecording.set(true); // 更新按钮状态 startRecordButton.setEnabled(false); stopRecordButton.setEnabled(true); uploadButton.setEnabled(false); // 创建定时任务发送音频数据 scheduler = Executors.newSingleThreadScheduledExecutor(); scheduler.scheduleAtFixedRate(this::uploadAudioData, 0, 100, TimeUnit.MILLISECONDS); // 提高发送频率 handler.sendEmptyMessage(0x12); // 发送开始录音的消息 // 发送开始录音控制指令 sendControlPacket("startRecorder"); // 播放TTS提示音 playTts("开始录音"); } catch (Exception e) { Log.e(TAG, "录音启动失败", e); sendErrorMessage("录音启动失败: " + e.getMessage()); releaseAudioResources(); } } /** * 停止录音操作 */ private void stopRecording() { if (!isRecording.get()) return; isRecording.set(false); releaseAudioResources(); // 更新按钮状态 stopRecordButton.setEnabled(false); uploadButton.setEnabled(true); handler.sendEmptyMessage(0x14); // 发送停止录音的消息 // 发送停止录音控制指令 sendControlPacket("stopRecor"); // 播放TTS提示音 playTts("停止录音"); } /** * 使用TTS播放指定文本 * @param text 要播放的文本内容 */ private void playTts(String text) { if (isTtsInitialized) { // 使用系统TTS播放 ttsEngine.speak(text, TextToSpeech.QUEUE_FLUSH, null); Log.i(TAG, "播放TTS: " + text); } else { Log.w(TAG, "TTS未初始化，无法播放: " + text); } } /** * 释放音频资源 */ private void releaseAudioResources() { if (audioRecord != null) { try { if (audioRecord.getRecordingState() == AudioRecord.RECORDSTATE_RECORDING) { audioRecord.stop(); } } catch (IllegalStateException e) { Log.e(TAG, "停止录音失败", e); } audioRecord.release(); audioRecord = null; } if (scheduler != null) { scheduler.shutdownNow(); scheduler = null; } } /** * 上传音频数据到服务器 */ private void uploadAudioData() { if (!isRecording.get() || clientSocket == null || clientSocket.isClosed() || socketWriter == null) { Log.w(TAG, "无法发送音频数据: 录音未进行或客户端未连接"); return; } byte[] buffer = new byte[BUFFER_SIZE]; try { int bytesRead = audioRecord.read(buffer, 0, BUFFER_SIZE); if (bytesRead > 0) { // 创建JSON数据包 JSONObject json = new JSONObject(); json.put("type", "recording"); json.put("data", Base64.encodeToString(buffer, 0, bytesRead, Base64.NO_WRAP)); // 使用NO_WRAP避免换行符 // 发送数据 synchronized (this) { if (socketWriter != null) { socketWriter.write(json.toString()); socketWriter.write("\n\n"); // 添加双换行作为结束标识 socketWriter.flush(); } } handler.sendEmptyMessage(0x13); // 发送录音数据的消息 } } catch (Exception e) { Log.e(TAG, "发送音频数据失败", e); sendErrorMessage("发送音频数据失败: " + e.getMessage()); } } /** * TTS初始化回调方法 * @param status 初始化状态 */ @Override public void onInit(int status) { if (status == TextToSpeech.SUCCESS) { // 设置默认语言为中文 int result = ttsEngine.setLanguage(Locale.CHINESE); if (result == TextToSpeech.LANG_MISSING_DATA || result == TextToSpeech.LANG_NOT_SUPPORTED) { Log.e(TAG, "TTS语言不支持中文"); } else { isTtsInitialized = true; Log.i(TAG, "TTS初始化成功，语言设置为中文"); } } else { Log.e(TAG, "TTS初始化失败"); } } /** * 发送控制指令包 * @param type 控制指令类型 */ private void sendControlPacket(String type) { if (clientSocket == null || clientSocket.isClosed() || socketWriter == null) { sendErrorMessage("无法发送控制指令: 客户端未连接"); return; } try { JSONObject packet = new JSONObject(); packet.put("type", type); packet.put("data", JSONObject.NULL); synchronized (this) { if (socketWriter != null) { socketWriter.write(packet.toString()); socketWriter.write("\n\n"); // 双换行作为结束标识 socketWriter.flush(); } } Log.i(TAG, "控制指令发送成功: " + type); } catch (Exception e) { Log.e(TAG, "发送控制指令失败", e); sendErrorMessage("发送控制指令失败: " + e.getMessage()); } } /** * 发送错误消息 * @param message 错误信息 */ private void sendErrorMessage(String message) { Message msg = handler.obtainMessage(0x16, message); handler.sendMessage(msg); } /** * 发送网络状态消息 * @param message 网络状态信息 */ private void sendNetworkMessage(String message) { Message msg = handler.obtainMessage(0x17, message); handler.sendMessage(msg); } /** * 上传录音文件（当前模式下无实际作用） */ private void uploadRecording() { Toast.makeText(this, "该模式下无需上传文件，已实时发送", Toast.LENGTH_SHORT).show(); } /** * 启动服务器监听 * @param port 监听端口号 */ private void startServer(int port) { executorService.execute(() -> { try { serverSocket = new ServerSocket(port); Log.i(TAG, "服务器启动，监听端口: " + port); sendNetworkMessage("服务器启动"); while (isServerRunning) { try { Socket socket = serverSocket.accept(); clientSocket = socket; // 创建输出流 synchronized (this) { socketWriter = new BufferedWriter( new OutputStreamWriter(socket.getOutputStream(), "UTF-8")); } handler.sendEmptyMessage(0x11); // 发送客户端连接成功的消息 Log.i(TAG, "客户端已连接: " + socket.getInetAddress()); sendNetworkMessage("客户端已连接"); // 启动双向通信处理 executorService.execute(() -> startCommunication(socket)); } catch (IOException e) { if (isServerRunning) { Log.e(TAG, "接受连接失败", e); sendErrorMessage("接受连接失败: " + e.getMessage()); } } } } catch (IOException e) { Log.e(TAG, "服务器启动失败", e); runOnUiThread(() -> Toast.makeText(MainActivity.this, "服务器启动失败: " + e.getMessage(), Toast.LENGTH_LONG).show()); } finally { closeServerSocket(); } }); } /** * 开始与客户端的通信 * @param socket 客户端Socket连接 */ private void startCommunication(Socket socket) { try (java.io.BufferedReader reader = new java.io.BufferedReader( new java.io.InputStreamReader(socket.getInputStream(), "UTF-8"))) { StringBuilder packetBuilder = new StringBuilder(); int c; while ((c = reader.read()) != -1 && isServerRunning) { char ch = (char) c; packetBuilder.append(ch); // 检测到连续两个换行符，表示一个完整的数据包结束 if (packetBuilder.length() >= 2 && packetBuilder.charAt(packetBuilder.length() - 2) == '\n' && packetBuilder.charAt(packetBuilder.length() - 1) == '\n') { String packet = packetBuilder.toString().trim(); packetBuilder.setLength(0); // 清空构建器 if (!packet.isEmpty()) { try { JSONObject jsonObject = new JSONObject(packet); handleReceivedPacket(jsonObject); } catch (JSONException e) { Log.w(TAG, "JSON解析失败: " + packet, e); } } } } } catch (IOException e) { if (isServerRunning) { Log.e(TAG, "通信中断", e); runOnUiThread(() -> Toast.makeText(MainActivity.this, "通信中断: " + e.getMessage(), Toast.LENGTH_SHORT).show()); } } finally { closeSocket(socket); } } /** * 处理接收到的数据包 * @param jsonObject 接收到的JSON数据包 */ private void handleReceivedPacket(JSONObject jsonObject) { try { String type = jsonObject.getString("type"); Object data = jsonObject.opt("data"); // 发送消息到主线程进行显示 Message msg = handler.obtainMessage(0x15, type + ": " + data); handler.sendMessage(msg); Log.i(TAG, "收到控制指令: " + type); // 根据不同类型执行不同操作 switch (type) { case "start_recording": runOnUiThread(this::startRecording); break; case "stop_recording": runOnUiThread(this::stopRecording); break; case "ping": sendResponse("pong"); break; } } catch (JSONException e) { Log.e(TAG, "处理数据包失败", e); } } /** * 发送响应给客户端 * @param responseType 响应类型 */ private void sendResponse(String responseType) { if (clientSocket == null || clientSocket.isClosed() || socketWriter == null) return; try { JSONObject response = new JSONObject(); response.put("type", responseType); response.put("data", ""); synchronized (this) { if (socketWriter != null) { socketWriter.write(response.toString()); socketWriter.write("\n\n"); socketWriter.flush(); } } Log.i(TAG, "发送响应: " + responseType); } catch (Exception e) { Log.e(TAG, "发送响应失败", e); } } /** * 关闭指定的Socket连接 * @param socket 要关闭的Socket */ private void closeSocket(Socket socket) { try { if (socket != null && !socket.isClosed()) { socket.close(); } } catch (IOException e) { Log.w(TAG, "关闭Socket失败", e); } // 如果是当前客户端Socket，重置引用 if (socket == clientSocket) { clientSocket = null; synchronized (this) { socketWriter = null; } sendNetworkMessage("客户端断开连接"); } } /** * 关闭服务器Socket */ private void closeServerSocket() { try { if (serverSocket != null && !serverSocket.isClosed()) { serverSocket.close(); } } catch (IOException e) { Log.w(TAG, "关闭ServerSocket失败", e); } } /** * Activity销毁时调用，释放所有资源 */ @Override protected void onDestroy() { super.onDestroy(); isServerRunning = false; // 关闭TTS引擎 if (ttsEngine != null) { ttsEngine.stop(); ttsEngine.shutdown(); } // 关闭所有资源 closeServerSocket(); closeSocket(clientSocket); executorService.shutdownNow(); releaseAudioResources(); Log.i(TAG, "应用已销毁"); sendNetworkMessage("服务已停止"); } /** * 权限请求结果回调 * @param requestCode 请求码 * @param permissions 请求的权限数组 * @param grantResults 权限授予结果 */ @Override public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) { super.onRequestPermissionsResult(requestCode, permissions, grantResults); if (requestCode == PERMISSION_REQUEST_CODE) { if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) { Toast.makeText(this, "录音权限已授予", Toast.LENGTH_SHORT).show(); } else { Toast.makeText(this, "录音权限被拒绝", Toast.LENGTH_SHORT).show(); } } } }
07-01
我们有两个脚本：一个是Python脚本（用于服务器端，处理音频流、语音识别、语音合成等），另一个是Android应用（用于录音并通过Socket发送音频数据）。目标：将TTS（文本到语音）功能集成到Python脚本中，并修改...
浅谈TCP/IP网络编程中socket的行为
weixin_30627381的博客
03-03 666
我认为，想要熟练掌握Linux下的TCP/IP网络编程，至少有三个层面的知识需要熟悉： 1. TCP/IP协议（如连接的建立和终止、重传和确认、滑动窗口和拥塞控制等等） 2. Socket I/O系统调用（重点如read/write），这是TCP/IP协议在应用层表现出来的行为。 3. 编写Performant, Scalable的服务器程序。包括多线程、IO Multiplexing、...
新手学习-Tcp的服务端与客户端的登录注册系统
JavaNewbie__
07-03 3483
客户端最近临近考试 还有好多科目需要预习 这个只能等到考试后再改一下了 现在这个程序问题很多 import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.InputStreamReader; import java.io.OutputStreamWriter; import java.net.InetAdd
Java中Socket实现客户端和服务端通信(多线程实现全双工通信)
爪白白的个人博客
05-06 7488
效果图 目录结构 服务端Server package server; import thread.SocketReader; import thread.SocketWrite; import java.io.InputStream; import java.io.PrintWriter; import java.net.ServerSocket; import java.net.Soc...
socket中read、write、send、recv函数的比较
amao992的专栏
09-22 1万+
What is the difference between read() and recv()?  From Andrew Gierth (andrew@erlenstar.demon.co.uk):  read() is equivalent to recv() with a flags parameter of 0. Other values for the flags parame
软件需求工程大作业(python spider)
08-08
资源下载链接为： https://pan.quark.cn/s/de4c4975d458 软件需求工程大作业(python spider)（最新、最全版本！打开链接下载即可用！）
VMD算法参数优化技巧：手动调整惩罚因子与包络熵的关系及其应用
08-08
内容概要：本文详细探讨了VMD（变分模态分解）算法中参数优化的具体方法，特别是惩罚因子α和模态数K的调整。文中通过实际案例展示了如何利用Python代码手动调整这两个关键参数，并通过计算包络熵评估优化效果。作者还分享了一些实用的经验法则和技术，如网格搜索、半自动策略以及肉眼验证等，帮助读者更好地理解和掌握VMD参数优化的实际操作。 适合人群：从事信号处理、机械故障诊断等相关领域的工程师和技术人员，尤其是那些需要对复杂信号进行有效分解和分析的专业人士。 使用场景及目标：适用于需要对振动信号或其他复杂信号进行精确分解的应用场合，旨在提高模态分解的质量，确保每个模态分量尽可能纯净，从而为后续的数据分析和故障诊断提供可靠的基础。 阅读建议：读者可以通过本文提供的具体实例和代码片段，结合自己的实际应用场景，尝试不同的参数配置，逐步积累经验和直觉，最终达到熟练掌握VMD参数优化的目的。同时，注意参数之间的相互影响，避免过度追求数学指标而忽视物理意义。
电力电子领域15KW充电模块电路设计解析及其功能应用
08-08
内容概要：本文深入探讨了15KW充电模块的电路设计及其功能应用。首先，文章详细介绍了充电模块的主电路构成，包括从交流电到直流电的转换过程，涉及整流、滤波电路，以及利用IGBT进行功率调节的关键步骤。接着，阐述了多种保护机制如过流、过压、欠压保护的具体实现方法，确保充电模块的安全性和稳定性。此外，还解释了充电模块的性能参数，如输出功率、电压范围、效率等，并讨论了模块间的通信方式（如CAN通信）和散热设计，强调了这些因素对于模块正常运作的重要性。 适合人群：从事电力电子、新能源汽车充电设施设计与维护的技术人员，以及对充电模块感兴趣的电子工程爱好者。 使用场景及目标：帮助技术人员更好地理解和优化充电模块的设计，提高其工作效率和产品质量；同时激发电子工程爱好者的兴趣，促进他们对该领域的进一步探索。 其他说明：文章不仅提供了详细的理论分析和技术细节，还结合实际应用场景进行了生动形象的比喻和解释，使复杂的电路概念变得通俗易懂。
基于SpringBoot+Vue的社区便民服务平台设计与实现【附万字论文+PPT+包部署+录制讲解视频】.zip
最新发布
08-08
标题基于SpringBoot+Vue的社区便民服务平台研究AI更换标题第1章引言介绍社区便民服务平台的研究背景、意义，以及基于SpringBoot+Vue技术的研究现状和创新点。1.1研究背景与意义分析社区便民服务的重要性，以及SpringBoot+Vue技术在平台建设中的优势。1.2国内外研究现状概述国内外在社区便民服务平台方面的发展现状。1.3研究方法与创新点阐述本文采用的研究方法和在SpringBoot+Vue技术应用上的创新之处。第2章相关理论介绍SpringBoot和Vue的相关理论基础，以及它们在社区便民服务平台中的应用。2.1SpringBoot技术概述解释SpringBoot的基本概念、特点及其在便民服务平台中的应用价值。2.2Vue技术概述阐述Vue的核心思想、技术特性及其在前端界面开发中的优势。2.3SpringBoot与Vue的整合应用探讨SpringBoot与Vue如何有效整合，以提升社区便民服务平台的性能。第3章平台需求分析与设计分析社区便民服务平台的需求，并基于SpringBoot+Vue技术进行平台设计。3.1需求分析明确平台需满足的功能需求和性能需求。3.2架构设计设计平台的整体架构，包括前后端分离、模块化设计等思想。3.3数据库设计根据平台需求设计合理的数据库结构，包括数据表、字段等。第4章平台实现与关键技术详细阐述基于SpringBoot+Vue的社区便民服务平台的实现过程及关键技术。4.1后端服务实现使用SpringBoot实现后端服务，包括用户管理、服务管理等核心功能。4.2前端界面实现采用Vue技术实现前端界面，提供友好的用户交互体验。4.3前后端交互技术探讨前后端数据交互的方式，如RESTful API、WebSocket等。第5章平台测试与优化对实现的社区便民服务平台进行全面测试，并针对问题进行优化。5.1测试环境与工具介绍测试
示波器FPGA设计方案：高性能、高可靠性的详细设计文档与代码资源
08-08
内容概要：本文介绍了示波器FPGA设计方案及其详细设计文档和代码资源。首先阐述了FPGA在现代电子技术中的重要性和应用背景，特别是在高性能模拟电路和嵌入式系统领域的广泛应用。接着明确了设计目标，即开发一款高性能、高可靠性、低成本的示波器FPGA芯片，并从模块化设计角度出发，详细解释了各个功能模块（如时钟管理、逻辑处理、存储器等）的设计原理和技术细节。最后提供了丰富的设计文档和代码资源，涵盖原理图、布局布线图、模块设计文档以及优化报告等，为开发者提供了宝贵的参考资料。 适用人群：从事FPGA设计、嵌入式系统开发的技术人员，尤其是对示波器FPGA设计感兴趣的工程师。 使用场景及目标：①用于理解和掌握示波器FPGA的设计方法和技术要点；②作为实际项目开发中的参考资料，帮助提升设计质量和开发效率。 其他说明：文中强调了FPGA设计资料的稀缺性，并呼吁更多人关注这一领域的发展，分享更多的设计经验和资源。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值