update

speech/source/speech_server.cc

@@ -0,0 +1,33 @@
+#include "speech_server.hpp"
+//语音识别子服务
+
+DEFINE_bool(run_mode, false, "程序的运行模式， false-调试；true-发布");
+DEFINE_string(log_file, "", "发布模式下，用于指定日志的输出文件");
+DEFINE_int32(log_level, 0, "发布模式下，用于指定日志的输出等级");
+
+DEFINE_string(registry_host, "http://127.0.0.1:2379", "服务注册中心地址");
+DEFINE_string(base_service, "/service", "服务监控根目录");
+DEFINE_string(instance_name, "/speech_service/instance", "当前实例名称");
+DEFINE_string(access_host, "127.0.0.1:10001", "当前实例的外部访问地址");
+
+DEFINE_int32(listen_port, 10001, "Rpc服务器监听端口");
+DEFINE_int32(rpc_timeout, -1, "Rpc调用超时时间");
+DEFINE_int32(rpc_threads, 1, "Rpc的IO线程数量");
+
+DEFINE_string(app_id, "118805148", "语音平台应用ID");
+DEFINE_string(api_key, "tRBBbRWdTOjHgr8xZX0s4Z2d", "语音平台API密钥");
+DEFINE_string(secret_key, "H2pyXuWi04uKEKK0T8jrTYo7Pj4UUUpC", "语音平台加密密钥");
+
+int main(int argc, char* argv[])
+{
+    google::ParseCommandLineFlags(&argc, &argv, true);
+    bite_im::init_logger(FLAGS_run_mode, FLAGS_log_file, FLAGS_log_level);
+
+    bite_im::SpeechServerBuilder ssb;
+    ssb.make_asr_object(FLAGS_app_id, FLAGS_api_key, FLAGS_secret_key);
+    ssb.make_rpc_server(FLAGS_listen_port, FLAGS_rpc_timeout, FLAGS_rpc_threads);
+    ssb.make_reg_object(FLAGS_registry_host, FLAGS_base_service + FLAGS_instance_name, FLAGS_access_host);
+    auto server = ssb.build();
+    server->start();
+    return 0;
+}

speech/source/speech_server.hpp

@@ -0,0 +1,123 @@
+#include <brpc/server.h>
+#include <butil/logging.h>
+
+#include "asr.hpp"  //语音识别模块
+#include "etcd.hpp" //服务注册模块
+#include "logger.hpp"  //日志模块
+#include "speech.pb.h" //protobuf框架代码
+
+using namespace bite_im;
+
+namespace bite_im{
+class SpeechServiceImpl : public bite_im::SpeechService {
+    public:
+        SpeechServiceImpl(const ASRClient::ptr &asr_client):
+            _asr_client(asr_client){}
+        ~SpeechServiceImpl(){}
+        void SpeechRecognition(google::protobuf::RpcController* controller,
+                       const ::bite_im::SpeechRecognitionReq* request,
+                       ::bite_im::SpeechRecognitionRsp* response,
+                       ::google::protobuf::Closure* done) {
+            LOG_DEBUG("收到语音转文字请求！");
+            brpc::ClosureGuard rpc_guard(done);
+            //1. 取出请求中的语音数据
+            //2. 调用语音sdk模块进行语音识别，得到响应
+            std::string err;
+            std::string res = _asr_client->recognize(request->speech_content(), err);
+            if (res.empty()) {
+                LOG_ERROR("{} 语音识别失败！", request->request_id());
+                response->set_request_id(request->request_id());
+                response->set_success(false);
+                response->set_errmsg("语音识别失败:" + err);
+                return;
+            }
+            //3. 组织响应
+            response->set_request_id(request->request_id());
+            response->set_success(true);
+            response->set_recognition_result(res);
+        }
+    private:
+        ASRClient::ptr _asr_client;
+};
+
+class SpeechServer {
+    public:
+        using ptr = std::shared_ptr<SpeechServer>;
+        SpeechServer(const ASRClient::ptr asr_client, 
+            const Registry::ptr &reg_client,
+            const std::shared_ptr<brpc::Server> &server):
+            _asr_client(asr_client),
+            _reg_client(reg_client),
+            _rpc_server(server){}
+        ~SpeechServer(){}
+        //搭建RPC服务器，并启动服务器
+        void start() {
+            _rpc_server->RunUntilAskedToQuit();
+        }
+    private:
+        ASRClient::ptr _asr_client;
+        Registry::ptr _reg_client;
+        std::shared_ptr<brpc::Server> _rpc_server;
+};
+
+class SpeechServerBuilder {
+    public:
+        //构造语音识别客户端对象
+        void make_asr_object(const std::string &app_id,
+            const std::string &api_key,
+            const std::string &secret_key) {
+            _asr_client = std::make_shared<ASRClient>(app_id, api_key, secret_key);
+        }
+        //用于构造服务注册客户端对象
+        void make_reg_object(const std::string &reg_host,
+            const std::string &service_name,
+            const std::string &access_host) {
+            _reg_client = std::make_shared<Registry>(reg_host);
+            _reg_client->registry(service_name, access_host);
+        }
+        //构造RPC服务器对象
+        void make_rpc_server(uint16_t port, int32_t timeout, uint8_t num_threads) {
+            if (!_asr_client) {
+                LOG_ERROR("还未初始化语音识别模块！");
+                abort();
+            }
+            _rpc_server = std::make_shared<brpc::Server>();
+            SpeechServiceImpl *speech_service = new SpeechServiceImpl(_asr_client);
+            int ret = _rpc_server->AddService(speech_service, 
+                brpc::ServiceOwnership::SERVER_OWNS_SERVICE);
+            if (ret == -1) {
+                LOG_ERROR("添加Rpc服务失败！");
+                abort();
+            }
+            brpc::ServerOptions options;
+            options.idle_timeout_sec = timeout;
+            options.num_threads = num_threads;
+            ret = _rpc_server->Start(port, &options);
+            if (ret == -1) {
+                LOG_ERROR("服务启动失败！");
+                abort();
+            }
+        }
+        SpeechServer::ptr build() {
+            if (!_asr_client) {
+                LOG_ERROR("还未初始化语音识别模块！");
+                abort();
+            }
+            if (!_reg_client) {
+                LOG_ERROR("还未初始化服务注册模块！");
+                abort();
+            }
+            if (!_rpc_server) {
+                LOG_ERROR("还未初始化RPC服务器模块！");
+                abort();
+            }
+            SpeechServer::ptr server = std::make_shared<SpeechServer>(
+                _asr_client, _reg_client, _rpc_server);
+            return server;
+        }
+    private:
+        ASRClient::ptr _asr_client;
+        Registry::ptr _reg_client;
+        std::shared_ptr<brpc::Server> _rpc_server;
+};
+}