blob: b37c06c24255d48289e2115964af8a05486d5610 [file] [log] [blame]
Tim Yao87d2f5a2020-12-26 17:03:58 -08001#include <stdio.h>
2#include <execinfo.h>
Tim Yaoe8c0d4a2019-11-27 14:47:35 -08003#include <sys/types.h>
4#include <unistd.h>
5#include <sys/stat.h>
6#include <fcntl.h>
Tim Yao41ac5872022-12-11 13:07:32 -08007#include <grp.h>
8#include <sys/un.h>
9#include <sys/socket.h>
10#include <sys/stat.h>
Tim Yaoe8c0d4a2019-11-27 14:47:35 -080011
12#include <boost/interprocess/managed_shared_memory.hpp>
13#include <cstdlib>
14#include <iomanip>
15#include <mutex>
Tim Yao031950f2020-12-16 11:36:20 -080016#include <chrono>
17#include <condition_variable>
18#include <thread>
Tim Yaoe8c0d4a2019-11-27 14:47:35 -080019#include <signal.h>
20
21#define LOG_TAG "audio_server"
22#include <cutils/log.h>
23
24#include <grpc/grpc.h>
25#include <grpcpp/server.h>
26#include <grpcpp/server_builder.h>
27#include <grpcpp/server_context.h>
Tim Yao41ac5872022-12-11 13:07:32 -080028#include <grpcpp/server_posix.h>
Tim Yaoe8c0d4a2019-11-27 14:47:35 -080029#include <grpcpp/security/server_credentials.h>
Tim Yaoaaa3bc52020-12-30 17:40:14 -080030#include <IpcBuffer/audio_server_shmem.h>
31#include <IpcBuffer/IpcBuffer.h>
Tim Yaoe8c0d4a2019-11-27 14:47:35 -080032#include "audio_if.h"
33#include "audio_service.grpc.pb.h"
cheng tong7d907882020-09-04 18:53:04 +080034#include "audio_effect_if.h"
Tim Yaoe8c0d4a2019-11-27 14:47:35 -080035
36using grpc::Server;
37using grpc::ServerBuilder;
38using grpc::ServerContext;
39using grpc::ServerReader;
40using grpc::ServerReaderWriter;
41using grpc::ServerWriter;
42using grpc::Status;
43using audio_service::StatusReturn;
44using audio_service::Volume;
45using audio_service::Mode;
46using audio_service::Mute;
47using audio_service::Kv_pairs;
48using audio_service::Keys;
49using audio_service::Handle;
50using audio_service::OpenOutputStream;
51using audio_service::Stream;
52using audio_service::OpenInputStream;
53using audio_service::CreateAudioPatch;
54using audio_service::AudioPortConfig;
55using audio_service::AudioGainConfig;
56using audio_service::AudioPortConfigDeviceExt;
57using audio_service::AudioPortConfigMixExt;
58using audio_service::AudioPortConfigSessionExt;
59using audio_service::StreamSetParameters;
60using audio_service::StreamGetParameters;
61using audio_service::StreamAudioEffect;
62using audio_service::StreamOutSetVolume;
63using audio_service::StreamReadWrite;
64using audio_service::GetFrameTimestampReturn;
65using audio_service::StreamGain;
cheng tong7d907882020-09-04 18:53:04 +080066using audio_service::EffectParameters;
Tim Yaoe8c0d4a2019-11-27 14:47:35 -080067using google::protobuf::Empty;
68
69using namespace boost::interprocess;
70using namespace audio_service;
71
72//#define DEBUG__
73
74#ifdef DEBUG__
75#define TRACE_ENTRY() ALOGI("%s enter\n", __func__)
76#define TRACE_EXIT() ALOGI("%s exit\n", __func__)
77#else
78#define TRACE_ENTRY()
79#define TRACE_EXIT()
80#endif
81
Tim Yaoaaa3bc52020-12-30 17:40:14 -080082typedef std::pair<IpcBuffer *, struct audio_stream_out *> streamout_map_t;
83typedef std::pair<IpcBuffer *, struct audio_stream_in *> streamin_map_t;
Tim Yaoe8c0d4a2019-11-27 14:47:35 -080084
85class AudioServiceImpl final : public AudioService::Service
86{
87 public:
Tim Yaoaaa3bc52020-12-30 17:40:14 -080088 explicit AudioServiceImpl()
89 : shm_(audio_server_shmem::getInstance(true)),
Tim Yaob414f482021-02-17 17:59:46 -080090 gc_runner_stop_(false),
Tim Yao031950f2020-12-16 11:36:20 -080091 gc_runner_(std::thread([this] {
92 while (!gc_runner_stop_) {
93 streamout_gc_();
94 streamin_gc_();
xingri.gao826841b2024-07-03 19:17:40 +080095 patch_gc_();
Tim Yao031950f2020-12-16 11:36:20 -080096 std::unique_lock<std::mutex> lock(gc_mutex_);
97 gc_cv_.wait_for(lock, std::chrono::milliseconds(500), [this]() { return gc_runner_stop_; });
98 }
99 })) {
Tim Yaoe8c0d4a2019-11-27 14:47:35 -0800100 if (audio_hw_load_interface(&dev_) == 0) {
cheng tong7d907882020-09-04 18:53:04 +0800101 if (dev_) {
102 effect_ = (audio_effect_t *)dev_->common.reserved[0];
103 }
Tim Yaoe8c0d4a2019-11-27 14:47:35 -0800104 //ALOGI(__func__, "[AudioServer] Get audio hal interface successfully.\n");
105 }
106 }
107
108 ~AudioServiceImpl() {
Tim Yao031950f2020-12-16 11:36:20 -0800109 {
110 std::lock_guard<std::mutex> lock(gc_mutex_);
111 gc_runner_stop_ = true;
112 }
113 gc_cv_.notify_one();
114 gc_runner_.join();
Tim Yaoe8c0d4a2019-11-27 14:47:35 -0800115 if (dev_) {
cheng tong7d907882020-09-04 18:53:04 +0800116 if (effect_) {
117 effect_ = nullptr;
118 }
Tim Yaoe8c0d4a2019-11-27 14:47:35 -0800119 audio_hw_unload_interface(dev_);
120 dev_ = nullptr;
121 }
122 }
123
124 Status Device_common_close(ServerContext* context, const Empty* empty, StatusReturn* response) {
125 TRACE_ENTRY();
126 if (!dev_) return Status::CANCELLED;
127
128 response->set_ret(dev_->common.close(&dev_->common));
129 return Status::OK;
130 }
131
132 Status Device_init_check(ServerContext* context, const Empty* empty, StatusReturn* response) {
133 TRACE_ENTRY();
134 if (!dev_) return Status::CANCELLED;
135
136 response->set_ret(dev_->init_check(dev_));
137 return Status::OK;
138 }
139
140 Status Device_set_voice_volume(ServerContext* context, const Volume* request, StatusReturn* response) {
141 TRACE_ENTRY();
142 if (!dev_) return Status::CANCELLED;
143
144 response->set_ret(dev_->set_voice_volume(dev_, request->vol()));
145 return Status::OK;
146 }
147
148 Status Device_set_master_volume(ServerContext* context, const Volume* request, StatusReturn* response) {
149 TRACE_ENTRY();
150 if (!dev_) return Status::CANCELLED;
151
152 response->set_ret(dev_->set_master_volume(dev_, request->vol()));
153 return Status::OK;
154 }
155
156 Status Device_get_master_volume(ServerContext* context, const Empty* request, StatusReturn* response) {
157 TRACE_ENTRY();
158 if (!dev_) return Status::CANCELLED;
159
160 float vol = 0.0;
161 response->set_ret(dev_->get_master_volume(dev_, &vol));
162 response->set_status_float(vol);
163 return Status::OK;
164 }
165
166 Status Device_set_mode(ServerContext* context, const Mode* request, StatusReturn* response) {
167 TRACE_ENTRY();
168 if (!dev_) return Status::CANCELLED;
169
170 response->set_ret(dev_->set_mode(dev_, (audio_mode_t)(request->mode())));
171 return Status::OK;
172 }
173
174 Status Device_set_mic_mute(ServerContext* context, const Mute* request, StatusReturn* response) {
175 TRACE_ENTRY();
176 if (!dev_) return Status::CANCELLED;
177
178 response->set_ret(dev_->set_mic_mute(dev_, request->mute()));
179 return Status::OK;
180 }
181
182 Status Device_get_mic_mute(ServerContext* context, const Empty* request, StatusReturn* response) {
183 TRACE_ENTRY();
184 if (!dev_) return Status::CANCELLED;
185
186 bool mute = false;
187 response->set_ret(dev_->get_mic_mute(dev_, &mute));
188 response->set_status_bool(mute);
189 return Status::OK;
190 }
191
192 Status Device_set_parameters(ServerContext* context, const Kv_pairs* request, StatusReturn* response) {
193 TRACE_ENTRY();
194 if (!dev_) return Status::CANCELLED;
195
196 response->set_ret(dev_->set_parameters(dev_, request->params().c_str()));
197 return Status::OK;
198 }
199
200 Status Device_get_parameters(ServerContext* context, const Keys* request, StatusReturn* response) {
201 TRACE_ENTRY();
202 if (!dev_) return Status::CANCELLED;
203
204 char *param = dev_->get_parameters(dev_, request->keys().c_str());
205 response->set_ret(param ? 0 : -1);
yuliang.hu19fdc8d2024-07-29 17:42:10 +0800206 if (param) {
207 response->set_status_string(std::string(param));
Tim Yaoe8c0d4a2019-11-27 14:47:35 -0800208
yuliang.hu19fdc8d2024-07-29 17:42:10 +0800209 // param is heap allocated and need free in behalf of client
210 free(param);
211 }
Tim Yaoe8c0d4a2019-11-27 14:47:35 -0800212
213 return Status::OK;
214 }
215
216 Status Device_get_input_buffer_size(ServerContext* context, const AudioConfig* request, StatusReturn* response) {
217 TRACE_ENTRY();
218 if (!dev_) return Status::CANCELLED;
219
220 struct audio_config config;
221 config.sample_rate = request->sample_rate();
222 config.channel_mask = request->channel_mask();
223 config.format = (audio_format_t)(request->format());
224 config.frame_count = request->frame_count();
225
226 response->set_ret(dev_->get_input_buffer_size(dev_, &config));
227 return Status::OK;
228 }
229
Tim Yao41ac5872022-12-11 13:07:32 -0800230 Status Device_open_output_stream(ServerContext* context, const OpenOutputStream* request, DeviceOpenStreamReturn* response) {
Tim Yaoe8c0d4a2019-11-27 14:47:35 -0800231 TRACE_ENTRY();
232 if (!dev_) return Status::CANCELLED;
233
Tim Yao41ac5872022-12-11 13:07:32 -0800234 int vpid, seq;
235 if (sscanf(request->name().c_str(), "%d-%d", &vpid, &seq) != 2) {
236 response->set_client_id(-1);
237 return Status::CANCELLED;
238 }
239 int client_id = get_client_pid_(context);
240 if (client_id < 0) {
241 response->set_client_id(-1);
242 return Status::CANCELLED;
243 }
244 char buf[32];
245 snprintf(buf, sizeof(buf), "%d-%d", client_id, seq);
246 std::string stream_id(buf);
247
Tim Yaoe8c0d4a2019-11-27 14:47:35 -0800248 struct audio_stream_out *stream = nullptr;
249 struct audio_config config;
250 config.sample_rate = request->config().sample_rate();
251 config.channel_mask = request->config().channel_mask();
252 config.format = (audio_format_t)(request->config().format());
253 config.frame_count = request->config().frame_count();
254
255 streamout_gc_();
256
257 response->set_ret(dev_->open_output_stream(dev_,
258 (audio_io_handle_t)(request->handle()),
259 (audio_devices_t)(request->devices()),
260 (audio_output_flags_t)(request->flags()),
261 &config,
262 &stream,
263 request->address().c_str()));
Tim Yao41ac5872022-12-11 13:07:32 -0800264 response->set_client_id(client_id);
Tim Yaoe8c0d4a2019-11-27 14:47:35 -0800265
266 if (stream) {
Tim Yao41ac5872022-12-11 13:07:32 -0800267 IpcBuffer * cb = shm_->find<IpcBuffer>(stream_id.c_str()).first;
Tim Yaoaaa3bc52020-12-30 17:40:14 -0800268 if (cb == nullptr) {
Tim Yao41ac5872022-12-11 13:07:32 -0800269 cb = shm_->construct<IpcBuffer>(stream_id.c_str())(stream_id.c_str(), request->size());
270 std::cout << "[AudioServer] open stream pid-seq " << stream_id.c_str() << std::endl;
271 ALOGI("%s pid-seq %s\n", __func__, stream_id.c_str());
Tim Yaoaaa3bc52020-12-30 17:40:14 -0800272 }
Tim Yaoe8c0d4a2019-11-27 14:47:35 -0800273
274 std::lock_guard<std::mutex> lock(map_out_mutex_);
275 streamout_map_.insert(
Tim Yao41ac5872022-12-11 13:07:32 -0800276 std::pair<const std::string, streamout_map_t>(stream_id, streamout_map_t(cb, stream)));
Tim Yaoe8c0d4a2019-11-27 14:47:35 -0800277 }
278
279 return Status::OK;
280 }
281
282 Status Device_close_output_stream(ServerContext* context, const Stream* request, StatusReturn* response) {
283 TRACE_ENTRY();
284 if (!dev_) return Status::CANCELLED;
285
286 std::map<const std::string, streamout_map_t >::iterator it = streamout_map_.find(request->name());
287 if (it == streamout_map_.end()) return Status::CANCELLED;
288
wei.du1e60c122021-11-04 11:01:16 +0800289 std::cout << "[AudioServer] close stream pid-seq " << request->name().c_str() << std::endl;
290 ALOGI("%s pid-seq %s\n", __func__, request->name().c_str());
Tim Yaoe8c0d4a2019-11-27 14:47:35 -0800291 dev_->close_output_stream(dev_, it->second.second);
292
293 if (it->second.first) {
Tim Yaoaaa3bc52020-12-30 17:40:14 -0800294 shm_->destroy<IpcBuffer>(request->name().c_str());
Tim Yaoe8c0d4a2019-11-27 14:47:35 -0800295 }
296
297 std::lock_guard<std::mutex> lock(map_out_mutex_);
298 streamout_map_.erase(it);
299
300 TRACE_EXIT();
301
302 return Status::OK;
303 }
304
Tim Yao41ac5872022-12-11 13:07:32 -0800305 Status Device_open_input_stream(ServerContext* context, const OpenInputStream* request, DeviceOpenStreamReturn* response) {
Tim Yaoe8c0d4a2019-11-27 14:47:35 -0800306 TRACE_ENTRY();
307 if (!dev_) return Status::CANCELLED;
308
Tim Yao41ac5872022-12-11 13:07:32 -0800309 int vpid, seq;
310 if (sscanf(request->name().c_str(), "%d-%d", &vpid, &seq) != 2) {
311 return Status::CANCELLED;
312 }
313 int client_id = get_client_pid_(context);
314 if (client_id < 0) {
315 return Status::CANCELLED;
316 }
317 char buf[32];
318 snprintf(buf, sizeof(buf), "%d-%d", client_id, seq);
319 std::string stream_id(buf);
320
Tim Yaoe8c0d4a2019-11-27 14:47:35 -0800321 struct audio_stream_in *stream = nullptr;
322 struct audio_config config;
323 config.sample_rate = request->config().sample_rate();
324 config.channel_mask = request->config().channel_mask();
325 config.format = (audio_format_t)(request->config().format());
326 config.frame_count = request->config().frame_count();
327
328 streamin_gc_();
329
330 response->set_ret(dev_->open_input_stream(dev_,
331 (audio_io_handle_t)(request->handle()),
332 (audio_devices_t)(request->devices()),
333 &config,
334 &stream,
335 (audio_input_flags_t)(request->flags()),
336 request->address().c_str(),
337 (audio_source_t)(request->source())));
Tim Yao41ac5872022-12-11 13:07:32 -0800338 response->set_client_id(client_id);
Tim Yaoe8c0d4a2019-11-27 14:47:35 -0800339
340 if (stream) {
Tim Yao41ac5872022-12-11 13:07:32 -0800341 IpcBuffer * cb = shm_->find<IpcBuffer>(stream_id.c_str()).first;
Tim Yaoe8c0d4a2019-11-27 14:47:35 -0800342 if (cb == nullptr)
Tim Yao41ac5872022-12-11 13:07:32 -0800343 cb = shm_->construct<IpcBuffer>(stream_id.c_str())(request->name().c_str(), request->size());
Tim Yaoe8c0d4a2019-11-27 14:47:35 -0800344
345 std::lock_guard<std::mutex> lock(map_in_mutex_);
346 streamin_map_.insert(
Tim Yao41ac5872022-12-11 13:07:32 -0800347 std::pair<const std::string, streamin_map_t>(stream_id, streamin_map_t(cb, stream)));
Tim Yaoe8c0d4a2019-11-27 14:47:35 -0800348 }
349
350 return Status::OK;
351 }
352
353 Status Device_close_input_stream(ServerContext* context, const Stream* request, StatusReturn* response) {
354 TRACE_ENTRY();
355 if (!dev_) return Status::CANCELLED;
356
357 std::map<const std::string, streamin_map_t >::iterator it = streamin_map_.find(request->name());
358 if (it == streamin_map_.end()) return Status::CANCELLED;
359
360 dev_->close_input_stream(dev_, it->second.second);
361
362 if (it->second.first) {
Tim Yaoaaa3bc52020-12-30 17:40:14 -0800363 shm_->destroy<IpcBuffer>(request->name().c_str());
Tim Yaoe8c0d4a2019-11-27 14:47:35 -0800364 }
365
366 std::lock_guard<std::mutex> lock(map_in_mutex_);
367 streamin_map_.erase(it);
368
369 return Status::OK;
370 }
371
372 Status Device_dump(ServerContext* context, const Empty* request, StatusReturn* response) {
373 TRACE_ENTRY();
374 if (!dev_) return Status::CANCELLED;
375
Tim Yaoab2a3a62020-10-29 15:33:55 -0700376 char *param = dev_->dump(dev_, 0);
377 response->set_ret(param ? 0 : -1);
yuliang.hu19fdc8d2024-07-29 17:42:10 +0800378 if (param) {
379 response->set_status_string(std::string(param));
Tim Yaoab2a3a62020-10-29 15:33:55 -0700380
yuliang.hu19fdc8d2024-07-29 17:42:10 +0800381 // param is heap allocated and need free
382 free(param);
383 }
Tim Yaoab2a3a62020-10-29 15:33:55 -0700384
Tim Yaoe8c0d4a2019-11-27 14:47:35 -0800385 return Status::OK;
386 }
387
388 Status Device_set_master_mute(ServerContext* context, const Mute* request, StatusReturn* response) {
389 TRACE_ENTRY();
390 if (!dev_) return Status::CANCELLED;
391
392 response->set_ret(dev_->set_master_mute(dev_, request->mute()));
393 return Status::OK;
394 }
395
396 Status Device_get_master_mute(ServerContext* context, const Empty* request, StatusReturn* response) {
397 TRACE_ENTRY();
398 if (!dev_) return Status::CANCELLED;
399
400 bool mute = false;
401 response->set_ret(dev_->get_master_mute(dev_, &mute));
402 response->set_status_bool(mute);
403 return Status::OK;
404 }
405
xingri.gao826841b2024-07-03 19:17:40 +0800406 Status Device_create_audio_patch(ServerContext* context, const CreateAudioPatch* request, DeviceCreatePatchReturn* response) {
Tim Yaoe8c0d4a2019-11-27 14:47:35 -0800407 TRACE_ENTRY();
408 if (!dev_) return Status::CANCELLED;
409
xingri.gao826841b2024-07-03 19:17:40 +0800410 int vpid, seq;
411 if (sscanf(request->name().c_str(), "%d-%d", &vpid, &seq) != 2) {
412 response->set_client_id(-1);
413 return Status::CANCELLED;
414 }
415 int client_id = get_client_pid_(context);
416 if (client_id < 0) {
417 response->set_client_id(-1);
418 return Status::CANCELLED;
419 }
420 char buf[32];
421 snprintf(buf, sizeof(buf), "%d-%d", client_id, seq);
422 std::string patch_id(buf);
423
424 ALOGI("%s [AudioServer] create patch pid-seq %s, vpid:%d, seq:%d, client_id:%d \n", __func__, request->name().c_str(), vpid, seq, client_id);
425
Tim Yaoe8c0d4a2019-11-27 14:47:35 -0800426 struct audio_port_config *sources, *sinks;
427 unsigned int num_sources = request->sources_size();
428 unsigned int num_sinks = request->sinks_size();
429
430 struct audio_port_config *configs = new struct audio_port_config[num_sources + num_sinks];
431
432 streamout_gc_();
433 streamin_gc_();
xingri.gao826841b2024-07-03 19:17:40 +0800434 patch_gc_();
Tim Yaoe8c0d4a2019-11-27 14:47:35 -0800435
436 for (int i = 0; i < num_sources + num_sinks; i++) {
437 const AudioPortConfig &config = (i < num_sources) ?
438 request->sources(i) : request->sinks(i - num_sources);
439 configs[i].id = config.id();
440 configs[i].role = (audio_port_role_t)config.role();
441 configs[i].type = (audio_port_type_t)config.type();
442 configs[i].config_mask = config.config_mask();
443 configs[i].sample_rate = config.sample_rate();
444 configs[i].channel_mask = config.channel_mask();
445 configs[i].format = (audio_format_t)config.format();
446
447 // gain
448 configs[i].gain.index = config.gain().index();
449 configs[i].gain.mode = (audio_gain_mode_t)config.gain().mode();
450 configs[i].gain.channel_mask = (audio_channel_mask_t)config.gain().channel_mask();
451 for (int j = 0; j < config.gain().values_size(); j++)
452 configs[i].gain.values[j] = config.gain().values(j);
453 configs[i].gain.ramp_duration_ms = config.gain().ramp_duration_ms();
454
455 if (configs[i].type == AUDIO_PORT_TYPE_DEVICE) {
456 // AudioPortConfigDeviceExt
457 configs[i].ext.device.hw_module = (audio_module_handle_t)config.device().hw_module();
458 configs[i].ext.device.type = (audio_devices_t)config.device().type();
yuliang.hu19fdc8d2024-07-29 17:42:10 +0800459 strncpy(configs[i].ext.device.address, config.device().address().c_str(), AUDIO_DEVICE_MAX_ADDRESS_LEN - 1);
460 configs[i].ext.device.address[AUDIO_DEVICE_MAX_ADDRESS_LEN - 1] = '\0';
Tim Yaoe8c0d4a2019-11-27 14:47:35 -0800461 } else if (configs[i].type == AUDIO_PORT_TYPE_MIX) {
462 // AudioPortConfigMixExt
463 configs[i].ext.mix.hw_module = (audio_module_handle_t)config.mix().hw_module();
464 configs[i].ext.mix.handle = (audio_io_handle_t)config.mix().handle();
465 configs[i].ext.mix.usecase.stream = (audio_stream_type_t)config.mix().stream_source();
466 } else if (configs[i].type == AUDIO_PORT_TYPE_SESSION) {
467 // AudioPortConfigSessionExt
468 configs[i].ext.session.session = (audio_session_t)config.session().session();
469 }
470 }
471
472 audio_patch_handle_t handle = (audio_patch_handle_t)(-1);
473 response->set_ret(dev_->create_audio_patch(dev_, num_sources,
474 configs, num_sinks, &configs[num_sources], &handle));
475 response->set_status_32((uint32_t)handle);
xingri.gao826841b2024-07-03 19:17:40 +0800476 response->set_client_id(client_id);
477
478 if (-1 != handle) {
479 std::lock_guard<std::mutex> lock(map_patch_mutex_);
480 patch_map_.insert(
481 std::pair<const std::string, audio_patch_handle_t>(patch_id, handle));
482 }
Tim Yaoe8c0d4a2019-11-27 14:47:35 -0800483
484 delete [] configs;
485
486 return Status::OK;
487 }
488
489 Status Device_release_audio_patch(ServerContext* context, const Handle* request, StatusReturn* response) {
490 TRACE_ENTRY();
491 if (!dev_) return Status::CANCELLED;
492
493 audio_patch_handle_t handle = (audio_patch_handle_t)(request->handle());
494 response->set_ret(dev_->release_audio_patch(dev_, handle));
xingri.gao826841b2024-07-03 19:17:40 +0800495 int client_id = get_client_pid_(context);
496 std::lock_guard<std::mutex> lock(map_patch_mutex_);
497 for (std::map<const std::string, audio_patch_handle_t >::iterator it = patch_map_.begin(); it != patch_map_.end(); it++) {
498 int pid, seq;
499 if (sscanf(it->first.c_str(), "%d-%d", &pid, &seq) == 2) {
500 if ((pid == client_id) && (handle == it->second)) {
501 patch_map_.erase(it);
502 break;
503 }
504 }
505 }
506
Tim Yaoe8c0d4a2019-11-27 14:47:35 -0800507 return Status::OK;
508 }
509
510 Status Device_set_audio_port_config(ServerContext* context, const AudioPortConfig* request, StatusReturn* response) {
511 TRACE_ENTRY();
512 if (!dev_) return Status::CANCELLED;
513
514 struct audio_port_config config;
515
516 config.id = request->id();
517 config.role = (audio_port_role_t)request->role();
518 config.type = (audio_port_type_t)request->type();
519 config.config_mask = request->config_mask();
520 config.sample_rate = request->sample_rate();
521 config.channel_mask = request->channel_mask();
522 config.format = (audio_format_t)request->format();
523
524 // gain
525 config.gain.index = request->gain().index();
526 config.gain.mode = (audio_gain_mode_t)request->gain().mode();
527 config.gain.channel_mask = (audio_channel_mask_t)request->gain().channel_mask();
528 for (int j = 0; j < request->gain().values_size(); j++)
529 config.gain.values[j] = request->gain().values(j);
530 config.gain.ramp_duration_ms = request->gain().ramp_duration_ms();
531
532 if (config.type == AUDIO_PORT_TYPE_DEVICE) {
533 // AudioPortConfigDeviceExt
534 config.ext.device.hw_module = (audio_module_handle_t)request->device().hw_module();
535 config.ext.device.type = (audio_devices_t)request->device().type();
yuliang.hu19fdc8d2024-07-29 17:42:10 +0800536 strncpy(config.ext.device.address, request->device().address().c_str(), AUDIO_DEVICE_MAX_ADDRESS_LEN - 1);
537 config.ext.device.address[AUDIO_DEVICE_MAX_ADDRESS_LEN - 1] = '\0';
Tim Yaoe8c0d4a2019-11-27 14:47:35 -0800538 } else if (config.type == AUDIO_PORT_TYPE_MIX) {
539 // AudioPortConfigMixExt
540 config.ext.mix.hw_module = (audio_module_handle_t)request->mix().hw_module();
541 config.ext.mix.handle = (audio_io_handle_t)request->mix().handle();
542 config.ext.mix.usecase.stream = (audio_stream_type_t)request->mix().stream_source();
543 } else if (config.type == AUDIO_PORT_TYPE_SESSION) {
544 // AudioPortConfigSessionExt
545 config.ext.session.session = (audio_session_t)request->session().session();
546 }
547
548 response->set_ret(dev_->set_audio_port_config(dev_, &config));
549 return Status::OK;
550 }
551
552 Status Stream_get_sample_rate(ServerContext* context, const Stream* request, StatusReturn* response) {
553 TRACE_ENTRY();
554 if (!dev_) return Status::CANCELLED;
555
556 struct audio_stream *stream = find_stream(request->name(), streamout_map_, streamin_map_);
557 if (stream == nullptr) return Status::CANCELLED;
558
559 response->set_ret(stream->get_sample_rate(stream));
560 return Status::OK;
561 }
562
563 Status Stream_get_buffer_size(ServerContext* context, const Stream* request, StatusReturn* response) {
564 TRACE_ENTRY();
565 if (!dev_) return Status::CANCELLED;
566
567 struct audio_stream *stream = find_stream(request->name(), streamout_map_, streamin_map_);
568 if (stream == nullptr) return Status::CANCELLED;
569
570 response->set_ret(stream->get_buffer_size(stream));
571 return Status::OK;
572 }
573
574 Status Stream_get_channels(ServerContext* context, const Stream* request, StatusReturn* response) {
575 TRACE_ENTRY();
576 if (!dev_) return Status::CANCELLED;
577
578 struct audio_stream *stream = find_stream(request->name(), streamout_map_, streamin_map_);
579 if (stream == nullptr) return Status::CANCELLED;
580
581 response->set_ret((uint32_t)stream->get_channels(stream));
582 return Status::OK;
583 }
584
585 Status Stream_get_format(ServerContext* context, const Stream* request, StatusReturn* response) {
586 TRACE_ENTRY();
587 if (!dev_) return Status::CANCELLED;
588
589 struct audio_stream *stream = find_stream(request->name(), streamout_map_, streamin_map_);
590 if (stream == nullptr) return Status::CANCELLED;
591
592 response->set_ret((uint32_t)stream->get_format(stream));
593 return Status::OK;
594 }
595
596 Status Stream_standby(ServerContext* context, const Stream* request, StatusReturn* response) {
597 TRACE_ENTRY();
598 if (!dev_) return Status::CANCELLED;
599
600 struct audio_stream *stream = find_stream(request->name(), streamout_map_, streamin_map_);
601 if (stream == nullptr) return Status::CANCELLED;
602
603 response->set_ret((uint32_t)stream->standby(stream));
604 return Status::OK;
605 }
606
607 Status Stream_get_device(ServerContext* context, const Stream* request, StatusReturn* response) {
608 TRACE_ENTRY();
609 if (!dev_) return Status::CANCELLED;
610
611 struct audio_stream *stream = find_stream(request->name(), streamout_map_, streamin_map_);
612 if (stream == nullptr) return Status::CANCELLED;
613
614 response->set_ret((uint32_t)stream->get_device(stream));
615 return Status::OK;
616 }
617
618 Status Stream_set_parameters(ServerContext* context, const StreamSetParameters* request, StatusReturn* response) {
619 TRACE_ENTRY();
620 if (!dev_) return Status::CANCELLED;
621
622 struct audio_stream *stream = find_stream(request->name(), streamout_map_, streamin_map_);
623 if (stream == nullptr) return Status::CANCELLED;
624
625 const char *kv_pairs = request->kv_pairs().c_str();
626 response->set_ret(stream->set_parameters(stream, kv_pairs));
627 return Status::OK;
628 }
629
630 Status Stream_get_parameters(ServerContext* context, const StreamGetParameters* request, StatusReturn* response) {
631 TRACE_ENTRY();
632 if (!dev_) return Status::CANCELLED;
633
634 struct audio_stream *stream = find_stream(request->name(), streamout_map_, streamin_map_);
635 if (stream == nullptr) return Status::CANCELLED;
636
637 char *param = stream->get_parameters(stream, request->keys().c_str());
638 response->set_ret(param ? 0 : -1);
yuliang.hu19fdc8d2024-07-29 17:42:10 +0800639 if (param) {
640 response->set_status_string(std::string(param));
Tim Yaoe8c0d4a2019-11-27 14:47:35 -0800641
yuliang.hu19fdc8d2024-07-29 17:42:10 +0800642 // param is heap allocated and need free in behalf of client
643 free(param);
644 }
Tim Yaoe8c0d4a2019-11-27 14:47:35 -0800645
646 return Status::OK;
647 }
648
649 Status StreamOut_get_latency(ServerContext* context, const Stream* request, StatusReturn* response) {
650 TRACE_ENTRY();
651 if (!dev_) return Status::CANCELLED;
652
653 struct audio_stream_out *stream = find_streamout(request->name(), streamout_map_);
654 if (stream == nullptr) return Status::CANCELLED;
655
656 response->set_ret(stream->get_latency(stream));
657 return Status::OK;
658 }
659
660 Status StreamOut_set_volume(ServerContext* context, const StreamOutSetVolume* request, StatusReturn* response) {
661 TRACE_ENTRY();
662 if (!dev_) return Status::CANCELLED;
663
664 struct audio_stream_out *stream = find_streamout(request->name(), streamout_map_);
665 if (stream == nullptr) return Status::CANCELLED;
666
667 response->set_ret(stream->set_volume(stream, request->left(), request->right()));
668 return Status::OK;
669 }
670
671 Status StreamOut_write(ServerContext* context, const StreamReadWrite* request, StatusReturn* response) {
672 TRACE_ENTRY();
673 if (!dev_) return Status::CANCELLED;
674
675 struct audio_stream_out *stream = find_streamout(request->name(), streamout_map_);
676 if (stream == nullptr) return Status::CANCELLED;
677
Tim Yaoaaa3bc52020-12-30 17:40:14 -0800678 IpcBuffer *cb = shm_->find<IpcBuffer>(request->name().c_str()).first;
679 response->set_ret(stream->write(stream, cb->start_ptr(), request->size()));
Tim Yaoe8c0d4a2019-11-27 14:47:35 -0800680 return Status::OK;
681 }
682
683 Status StreamOut_get_render_position(ServerContext* context, const Stream* request, StatusReturn* response) {
684 TRACE_ENTRY();
685 if (!dev_) return Status::CANCELLED;
686
687 struct audio_stream_out *stream = find_streamout(request->name(), streamout_map_);
688 if (stream == nullptr) return Status::CANCELLED;
689
690 uint32_t dsp_frames = 0;
691 response->set_ret(stream->get_render_position(stream, &dsp_frames));
692 response->set_status_32(dsp_frames);
693 return Status::OK;
694 }
695
696 Status StreamOut_get_next_write_timestamp(ServerContext* context, const Stream* request, StatusReturn* response) {
697 TRACE_ENTRY();
698 if (!dev_) return Status::CANCELLED;
699
700 struct audio_stream_out *stream = find_streamout(request->name(), streamout_map_);
701 if (stream == nullptr) return Status::CANCELLED;
702
703 int64_t timestamp = 0;
704 response->set_ret(stream->get_next_write_timestamp(stream, &timestamp));
705 response->set_status_64(timestamp);
706 return Status::OK;
707 }
708
709 Status StreamOut_pause(ServerContext* context, const Stream* request, StatusReturn* response) {
710 TRACE_ENTRY();
711 if (!dev_) return Status::CANCELLED;
712
713 struct audio_stream_out *stream = find_streamout(request->name(), streamout_map_);
714 if (stream == nullptr) return Status::CANCELLED;
715
716 response->set_ret(stream->pause(stream));
717 return Status::OK;
718 }
719
720 Status StreamOut_resume(ServerContext* context, const Stream* request, StatusReturn* response) {
721 TRACE_ENTRY();
722 if (!dev_) return Status::CANCELLED;
723
724 struct audio_stream_out *stream = find_streamout(request->name(), streamout_map_);
725 if (stream == nullptr) return Status::CANCELLED;
726
727 response->set_ret(stream->resume(stream));
728 return Status::OK;
729 }
730
731 Status StreamOut_flush(ServerContext* context, const Stream* request, StatusReturn* response) {
732 TRACE_ENTRY();
733 if (!dev_) return Status::CANCELLED;
734
735 struct audio_stream_out *stream = find_streamout(request->name(), streamout_map_);
736 if (stream == nullptr) return Status::CANCELLED;
737
738 response->set_ret(stream->flush(stream));
739 return Status::OK;
740 }
741
742 Status StreamOut_get_presentation_position(ServerContext* context, const Stream* request, GetFrameTimestampReturn* response) {
743 TRACE_ENTRY();
744 if (!dev_) return Status::CANCELLED;
745
746 struct audio_stream_out *stream = find_streamout(request->name(), streamout_map_);
747 if (stream == nullptr) return Status::CANCELLED;
748
749 uint64_t frames = 0;
750 struct timespec timestamp;
751 response->set_ret(stream->get_presentation_position(stream, &frames, &timestamp));
752 response->set_frames(frames);
753 response->mutable_timestamp()->set_seconds((int64_t)timestamp.tv_sec);
754 response->mutable_timestamp()->set_nanos(timestamp.tv_nsec);
755 return Status::OK;
756 }
757
758 Status StreamIn_set_gain(ServerContext* context, const StreamGain* request, StatusReturn* response) {
759 TRACE_ENTRY();
760 if (!dev_) return Status::CANCELLED;
761
762 struct audio_stream_in *stream = find_streamin(request->name(), streamin_map_);
763 if (stream == nullptr) return Status::CANCELLED;
764
765 response->set_ret(stream->set_gain(stream, request->gain()));
766 return Status::OK;
767 }
768
769 Status StreamIn_read(ServerContext* context, const StreamReadWrite* request, StatusReturn* response) {
770 TRACE_ENTRY();
771 if (!dev_) return Status::CANCELLED;
772
773 struct audio_stream_in *stream = find_streamin(request->name(), streamin_map_);
774 if (stream == nullptr) return Status::CANCELLED;
775
Tim Yaoaaa3bc52020-12-30 17:40:14 -0800776 IpcBuffer *cb = shm_->find<IpcBuffer>(request->name().c_str()).first;
Blance Tang4c7ceb92021-03-05 17:12:40 +0800777 response->set_ret(stream->read(stream, cb->start_ptr(), std::min((size_t) request->size(), cb->capacity())));
Tim Yaoe8c0d4a2019-11-27 14:47:35 -0800778 return Status::OK;
779 }
780
781 Status StreamIn_get_input_frames_lost(ServerContext* context, const Stream* request, StatusReturn* response) {
782 TRACE_ENTRY();
783 if (!dev_) return Status::CANCELLED;
784
785 struct audio_stream_in *stream = find_streamin(request->name(), streamin_map_);
786 if (stream == nullptr) return Status::CANCELLED;
787
788 response->set_ret(stream->get_input_frames_lost(stream));
789 return Status::OK;
790 }
791
792 Status StreamIn_get_capture_position(ServerContext* context, const Stream* request, GetCapturePositionReturn* response) {
793 TRACE_ENTRY();
794 if (!dev_) return Status::CANCELLED;
795
796 struct audio_stream_in *stream = find_streamin(request->name(), streamin_map_);
797 if (stream == nullptr) return Status::CANCELLED;
798
799 int64_t frames = 0;
800 int64_t time = 0;
801 response->set_ret(stream->get_capture_position(stream, &frames, &time));
802 response->set_frames(frames);
803 response->set_time(time);
804
805 return Status::OK;
806 }
807
808 Status Service_ping(ServerContext* context, const Empty* empty, StatusReturn* response) {
809 TRACE_ENTRY();
810 response->set_status_32(0);
811 return Status::OK;
812 }
813
cheng tong7d907882020-09-04 18:53:04 +0800814 Status Effect_set_parameters(ServerContext* context, const EffectParameters* request, StatusReturn* response) {
815 TRACE_ENTRY();
816 if (!dev_ || !effect_) return Status::CANCELLED;
817
818 aml_audio_effect_type_e type = (aml_audio_effect_type_e)request->type();
819 uint32_t cmdSize = request->cmd_size();
820 void *pCmdData = (void *)request->cmd_data().data();
821 uint32_t replySize = request->reply_size();
822 uint32_t pReplyData = 0;
823
824 response->set_ret(effect_->set_parameters(type, cmdSize, pCmdData, &replySize, &pReplyData));
825 response->set_status_32(pReplyData);
826 return Status::OK;
827 }
828
829 Status Effect_get_parameters(ServerContext* context, const EffectParameters* request, StatusReturn* response) {
830 TRACE_ENTRY();
831 if (!dev_ || !effect_) return Status::CANCELLED;
832
833 aml_audio_effect_type_e type = (aml_audio_effect_type_e)request->type();
834 uint32_t cmdSize = request->cmd_size();
835 void *pCmdData = (void *)request->cmd_data().data();
836 uint32_t replySize = request->reply_size();
837 void * pReplyData = malloc(replySize);
838
839 response->set_ret(effect_->get_parameters(type, cmdSize, pCmdData, &replySize, pReplyData));
840 response->set_status_bytes(pReplyData, replySize);
841 free(pReplyData);
842 pReplyData = nullptr;
843 return Status::OK;
844 }
845
Tim Yaoe8c0d4a2019-11-27 14:47:35 -0800846 private:
Tim Yao41ac5872022-12-11 13:07:32 -0800847 static int get_client_pid_(grpc::ServerContext* context)
848 {
849 ALOGI("peer %s", context->peer().c_str());
850
851 // get the client socket fd
852 int socketFd = -1;
853 if ((sscanf(context->peer().c_str(), "fd:%d", &socketFd) != 1) || (socketFd < 0)) {
854 ALOGE("Error: failed to get fd of the client");
855 return -1;
856 }
857
858 // sanity check it's an actual fd by dup'ing it
859 int duppedFd = fcntl(socketFd, F_DUPFD_CLOEXEC, 3);
860 if (duppedFd < 0) {
861 ALOGE("Error: failed to dup client socket fd (%d - %s)", errno, strerror(errno));
862 return -1;
863 }
864
865 struct ucred cred;
866 socklen_t credLen = sizeof(cred);
867 if (getsockopt(duppedFd, SOL_SOCKET, SO_PEERCRED, &cred, &credLen) < 0) {
868 ALOGE("Error: failed to get creds from client socket (%d - %s)", errno, strerror(errno));
869 cred.pid = -1;
870 }
871
872 if (close(duppedFd) != 0) {
873 ALOGE("Error: failed to close dup'd socket (%d - %s)", errno, strerror(errno));
874 }
875
876 return cred.pid;
877 }
878
879
Tim Yaoe8c0d4a2019-11-27 14:47:35 -0800880 void streamout_gc_()
881 {
882 std::lock_guard<std::mutex> lock_out(map_out_mutex_);
883 for (std::map<const std::string, streamout_map_t >::iterator it = streamout_map_.begin(); it != streamout_map_.end(); ) {
884 int pid, seq;
885 bool need_close = false;
886
887 if (sscanf(it->first.c_str(), "%d-%d", &pid, &seq) == 2) {
Tim Yaoe8c0d4a2019-11-27 14:47:35 -0800888 // Garbage collect streams when PID does not exists.
889 // It happens when client side crashed, or the client
890 // side does not have the right sequence to close opened streams.
891 if ((kill(pid, 0) == -1) && (errno == ESRCH)) {
892 need_close = true;
893 }
894 }
895 if (need_close) {
Tim Yao031950f2020-12-16 11:36:20 -0800896 ALOGI("Close disconnected output stream from PID %d", pid);
Tim Yaoe8c0d4a2019-11-27 14:47:35 -0800897 dev_->close_output_stream(dev_, it->second.second);
898 if (it->second.first) {
Tim Yaoaaa3bc52020-12-30 17:40:14 -0800899 shm_->destroy<IpcBuffer>(it->first.c_str());
Tim Yaoe8c0d4a2019-11-27 14:47:35 -0800900 }
901 streamout_map_.erase(it++);
902 } else {
903 ++it;
904 }
905 }
906 }
907
908 void streamin_gc_()
909 {
910 std::lock_guard<std::mutex> lock_out(map_in_mutex_);
911 for (std::map<const std::string, streamin_map_t >::iterator it = streamin_map_.begin(); it != streamin_map_.end(); ) {
912 int pid, seq;
913 bool need_close = false;
914
915 if (sscanf(it->first.c_str(), "%d-%d", &pid, &seq) == 2) {
916 // Garbage collect streams when PID does not exists.
917 // It happens when client side crashed, or the client
918 // side does not have the right sequence to close opened streams.
919 if (kill(pid, 0) == ESRCH) {
920 need_close = true;
921 }
922 }
923 if (need_close) {
924 dev_->close_input_stream(dev_, it->second.second);
925 streamin_map_.erase(it++);
926 } else {
927 ++it;
928 }
929 }
930 }
931
xingri.gao826841b2024-07-03 19:17:40 +0800932 void patch_gc_()
933 {
934 std::lock_guard<std::mutex> lock_out(map_patch_mutex_);
935 for (std::map<const std::string, audio_patch_handle_t >::iterator it = patch_map_.begin(); it != patch_map_.end(); ) {
936 int pid, seq;
937 bool need_close = false;
938
939 if (sscanf(it->first.c_str(), "%d-%d", &pid, &seq) == 2) {
940 // Garbage collect patch when PID does not exists.
941 // It happens when client side crashed, or the client
942 // side does not have the right sequence to close opened streams.
943 if ((kill(pid, 0) == -1) && (errno == ESRCH)) {
944 need_close = true;
945 }
946 }
947 if (need_close) {
948 ALOGI("Close disconnected patch from PID %d, handle:%d", pid, it->second);
949 dev_->release_audio_patch(dev_, it->second);
950 patch_map_.erase(it++);
951 } else {
952 ++it;
953 }
954 }
955 }
956
Tim Yaoe8c0d4a2019-11-27 14:47:35 -0800957 struct audio_stream *find_stream(std::string name,
958 std::map<const std::string, streamout_map_t> &map_out,
959 std::map<const std::string, streamin_map_t> &map_in)
960 {
961 std::lock_guard<std::mutex> lock_out(map_out_mutex_);
962 std::map<const std::string, streamout_map_t >::iterator it_out = map_out.find(name);
963 if (it_out != map_out.end()) {
964 return &it_out->second.second->common;
965 }
966
967 std::lock_guard<std::mutex> lock_in(map_in_mutex_);
968 std::map<const std::string, streamin_map_t >::iterator it_in = map_in.find(name);
969 if (it_in != map_in.end()) {
970 return &it_in->second.second->common;
971 }
972
973 return nullptr;
974 }
975
976 struct audio_stream_out *find_streamout(std::string name,
977 std::map<const std::string, streamout_map_t> &map_out)
978 {
979 std::lock_guard<std::mutex> lock(map_out_mutex_);
980 std::map<const std::string, streamout_map_t >::iterator it = map_out.find(name);
981 if (it != map_out.end()) {
982 return it->second.second;
983 }
984
985 return nullptr;
986 }
987
988 struct audio_stream_in *find_streamin(std::string name,
989 std::map<const std::string, streamin_map_t> &map_in)
990 {
991 std::lock_guard<std::mutex> lock(map_in_mutex_);
992 std::map<const std::string, streamin_map_t >::iterator it = map_in.find(name);
993 if (it != map_in.end()) {
994 return it->second.second;
995 }
996
997 return nullptr;
998 }
999
Tim Yaoaaa3bc52020-12-30 17:40:14 -08001000 managed_shared_memory *shm_;
Tim Yaoe8c0d4a2019-11-27 14:47:35 -08001001
1002 /* audio hal interface */
1003 struct audio_hw_device *dev_;
cheng tong7d907882020-09-04 18:53:04 +08001004 audio_effect_t *effect_;
Tim Yaoe8c0d4a2019-11-27 14:47:35 -08001005 static std::mutex map_in_mutex_;
1006 static std::mutex map_out_mutex_;
xingri.gao826841b2024-07-03 19:17:40 +08001007 static std::mutex map_patch_mutex_;
Tim Yaoe8c0d4a2019-11-27 14:47:35 -08001008 std::map<const std::string, streamout_map_t > streamout_map_;
1009 std::map<const std::string, streamin_map_t > streamin_map_;
xingri.gao826841b2024-07-03 19:17:40 +08001010 std::map<const std::string, audio_patch_handle_t > patch_map_;
Tim Yao031950f2020-12-16 11:36:20 -08001011
1012 /* gc thread to close dead streams */
1013 bool gc_runner_stop_;
1014 std::mutex gc_mutex_;
1015 std::condition_variable gc_cv_;
1016 std::thread gc_runner_;
Tim Yaoe8c0d4a2019-11-27 14:47:35 -08001017};
1018
1019std::mutex AudioServiceImpl::map_out_mutex_;
1020std::mutex AudioServiceImpl::map_in_mutex_;
xingri.gao826841b2024-07-03 19:17:40 +08001021std::mutex AudioServiceImpl::map_patch_mutex_;
Tim Yaoe8c0d4a2019-11-27 14:47:35 -08001022
wei.duc64b06a2022-01-17 16:51:12 +08001023static void SetAudioPermissions(const char* file_path){
1024 struct stat buf;
yuliang.hu19fdc8d2024-07-29 17:42:10 +08001025 /*coverity[toctou]: The file_path status will not change after stat check*/
wei.duc64b06a2022-01-17 16:51:12 +08001026 if (stat(file_path, &buf) != 0)
1027 return;
1028
yuliang.hu19fdc8d2024-07-29 17:42:10 +08001029 int ret = chmod(file_path, (buf.st_mode & 0711) | 0066);
1030 if (-1 == ret) {
1031 ALOGE("Error:chmod, need check!!");
1032 }
wei.duc64b06a2022-01-17 16:51:12 +08001033}
1034
Tim Yao41ac5872022-12-11 13:07:32 -08001035static bool runListenerLoop(const std::unique_ptr<grpc::Server> &server, const std::string &address)
1036{
1037 if (address.find("unix://") != 0) {
1038 ALOGE("Error: must be an 'unix://' server address");
1039 return false;
1040 }
1041
1042 std::string socketPath = address.substr(strlen("unix://"));
1043
1044 struct stat st;
yuliang.hu19fdc8d2024-07-29 17:42:10 +08001045 /*coverity[toctou]*/
Tim Yao41ac5872022-12-11 13:07:32 -08001046 if ((stat(socketPath.c_str(), &st) == 0) && ((st.st_mode & S_IFMT) == S_IFSOCK)) {
1047 unlink(socketPath.c_str());
1048 }
1049
1050 int serverSock = socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0);
1051 if (serverSock < 0) {
1052 ALOGE("Error: failed to create unix socket (%d - %s)", errno, strerror(errno));
1053 return false;
1054 }
1055
1056 struct sockaddr_un serverAddr;
1057 memset(&serverAddr, 0, sizeof(serverAddr));
1058 serverAddr.sun_family = AF_UNIX;
1059 strncpy(serverAddr.sun_path, socketPath.c_str(), sizeof(serverAddr.sun_path) - 1);
1060
1061 if (bind(serverSock, (struct sockaddr*)&serverAddr, sizeof(serverAddr)) != 0) {
1062 ALOGE("Error: failed to bind to unix socket @ '%s' (%d - %s)",
1063 socketPath.c_str(), errno, strerror(errno));
yuliang.hu19fdc8d2024-07-29 17:42:10 +08001064 close(serverSock);
Tim Yao41ac5872022-12-11 13:07:32 -08001065 return false;
1066 }
1067
1068 SetAudioPermissions(socketPath.c_str());
1069
1070 if (listen(serverSock, 5) == -1) {
1071 ALOGE("Error: failed to set socket to listening mode (%d - %s)",
1072 errno, strerror(errno));
1073 return false;
1074 }
1075
1076 for (;;) {
1077 struct sockaddr_un clientAddr;
1078 socklen_t clientAddrLen = sizeof(clientAddr);
1079 int clientSock = TEMP_FAILURE_RETRY(accept4(serverSock,(struct sockaddr *) &clientAddr, &clientAddrLen, SOCK_NONBLOCK | SOCK_CLOEXEC));
1080 if (clientSock < 0) {
1081 ALOGE("Error: accepting new connection (%d - %s)", errno, strerror(errno));
1082 continue;
1083 }
1084
1085 struct ucred cred;
1086 socklen_t credLen = sizeof(cred);
1087 if (getsockopt(clientSock, SOL_SOCKET, SO_PEERCRED, &cred, &credLen) < 0) {
1088 ALOGE("Error: failed to get creds from client socket (%d - %s)",
1089 errno, strerror(errno));
1090 close(clientSock);
1091 continue;
1092 }
1093
1094 grpc::AddInsecureChannelFromFd(server.get(), clientSock);
1095 }
1096
1097 return true;
1098}
1099
Tim Yaoaaa3bc52020-12-30 17:40:14 -08001100void RunServer()
Tim Yaoe8c0d4a2019-11-27 14:47:35 -08001101{
Tim Yao1b84e362020-08-24 12:51:36 -07001102 const char *url = std::getenv("AUDIO_SERVER_SOCKET");
wei.duc64b06a2022-01-17 16:51:12 +08001103 std::string socket_location("/tmp/audio_socket");
1104 std::string server_address("unix://" + socket_location);
Tim Yaoaaa3bc52020-12-30 17:40:14 -08001105 AudioServiceImpl service;
Tim Yao1b84e362020-08-24 12:51:36 -07001106 if (url) {
1107 server_address = url;
1108 }
Tim Yaoe8c0d4a2019-11-27 14:47:35 -08001109 ServerBuilder builder;
Tim Yao41ac5872022-12-11 13:07:32 -08001110 //builder.AddListeningPort(server_address, grpc::InsecureServerCredentials());
Tim Yaoe8c0d4a2019-11-27 14:47:35 -08001111 builder.RegisterService(&service);
1112 std::unique_ptr<Server> server(builder.BuildAndStart());
wei.duc64b06a2022-01-17 16:51:12 +08001113 SetAudioPermissions(socket_location.c_str());
1114 SetAudioPermissions("/dev/shm/AudioServiceShmem");
Tim Yaoe8c0d4a2019-11-27 14:47:35 -08001115 std::cout << "[AudioServer] listening on " << server_address << std::endl;
Tim Yao41ac5872022-12-11 13:07:32 -08001116 runListenerLoop(server, server_address);
Tim Yaoe8c0d4a2019-11-27 14:47:35 -08001117 server->Wait();
1118}
1119
1120static int daemonize()
1121{
1122 int fd_pid;
1123 const char pidfile[] = "/var/run/audio_server.pid";
1124 char pid[10];
1125
1126 fd_pid = open(pidfile, O_RDWR|O_CREAT, 0600);
1127 if (fd_pid == -1) {
1128 fprintf(stderr, "Unable to open PID lock file\n");
1129 return -1;
1130 }
1131
1132 if (lockf(fd_pid, F_TLOCK, 0) == -1) {
1133 fprintf(stderr, "Unable to lock PID file, daemon is existing.\n");
1134 return -2;
1135 }
1136
1137 snprintf(pid, sizeof(pid), "%d", getpid());
1138 write(fd_pid, pid, strlen(pid));
1139
1140 return 0;
1141}
1142
Tim Yao87d2f5a2020-12-26 17:03:58 -08001143void handler(int sig)
1144{
wei.duc2dbbd82023-05-04 09:13:03 +00001145 void *array[100];
1146 size_t size, i = 0;
1147 char ** trace;
Tim Yao87d2f5a2020-12-26 17:03:58 -08001148
1149 // get void*'s for all entries on the stack
wei.duc2dbbd82023-05-04 09:13:03 +00001150 size = backtrace(array, 100);
Tim Yao87d2f5a2020-12-26 17:03:58 -08001151
1152 // print out all the frames to stderr
wei.duc2dbbd82023-05-04 09:13:03 +00001153 fprintf(stderr, "Error: signal %d, size %d\n", sig, size);
1154 ALOGE("Error: signal %d, size %d", sig, size);
1155 trace = backtrace_symbols(array, size);
1156
1157 if (trace) {
1158 for (i = 0; i < size; i++) {
1159 ALOGE("%s", trace[i]);
1160 fprintf(stderr, "%s\n", trace[i]);
1161 }
1162 } else {
1163 fprintf(stderr, "backtrace symbols error!!!\n");
1164 ALOGE("backtrace symbols error!!!");
1165 }
1166
Tim Yao87d2f5a2020-12-26 17:03:58 -08001167 exit(1);
1168}
1169
yuliang.hu19fdc8d2024-07-29 17:42:10 +08001170/*coverity[UNCAUGHT_EXCEPT]: Do not catch exceptions in order to generate coredumps*/
Tim Yaoe8c0d4a2019-11-27 14:47:35 -08001171int main(int argc, char** argv)
1172{
1173 int r = daemonize();
1174 if (r < 0)
1175 return r;
1176
yuliang.hu181f1032024-04-25 07:41:48 +00001177 //signal(SIGSEGV, handler);
1178 //signal(SIGABRT, handler);
1179 //signal(SIGFPE, handler);
Tim Yao87d2f5a2020-12-26 17:03:58 -08001180
Tim Yaoaaa3bc52020-12-30 17:40:14 -08001181 RunServer();
Tim Yaoe8c0d4a2019-11-27 14:47:35 -08001182 return 0;
1183}