1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "audio_ctrl_channel.h"
17
18 #include <securec.h>
19
20 #include "daudio_hisysevent.h"
21 #include "daudio_hitrace.h"
22
23 #undef DH_LOG_TAG
24 #define DH_LOG_TAG "AudioCtrlChannel"
25
26 namespace OHOS {
27 namespace DistributedHardware {
CreateSession(const std::shared_ptr<IAudioChannelListener> & listener,const std::string & sessionName)28 int32_t AudioCtrlChannel::CreateSession(const std::shared_ptr<IAudioChannelListener> &listener,
29 const std::string &sessionName)
30 {
31 DHLOGI("Create session, peerDevId: %s.", GetAnonyString(peerDevId_).c_str());
32 if (listener == nullptr) {
33 DHLOGE("Channel listener is null.");
34 DAudioHisysevent::GetInstance().SysEventWriteFault(DAUDIO_OPT_FAIL, ERR_DH_AUDIO_TRANS_NULL_VALUE,
35 "daudio channel listener is null.");
36 return ERR_DH_AUDIO_TRANS_NULL_VALUE;
37 }
38
39 DAUDIO_SYNC_TRACE(DAUDIO_CREATE_CTRL_SESSION);
40 int32_t ret =
41 SoftbusAdapter::GetInstance().CreateSoftbusSessionServer(PKG_NAME, sessionName, peerDevId_);
42 if (ret != DH_SUCCESS) {
43 DHLOGE("Create softbus session failed ret: %d.", ret);
44 DAudioHisysevent::GetInstance().SysEventWriteFault(DAUDIO_OPT_FAIL, ret,
45 "daudio create softbus session failed.");
46 return ret;
47 }
48
49 ret = SoftbusAdapter::GetInstance().RegisterSoftbusListener(shared_from_this(), sessionName, peerDevId_);
50 if (ret != DH_SUCCESS) {
51 DHLOGE("Register softbus adapter listener failed ret: %d.", ret);
52 DAudioHisysevent::GetInstance().SysEventWriteFault(DAUDIO_OPT_FAIL, ret,
53 "daudio register softbus adapter listener failed.");
54 return ret;
55 }
56
57 channelListener_ = listener;
58 sessionName_ = sessionName;
59 DHLOGI("Create softbus session success.");
60 return DH_SUCCESS;
61 }
62
ReleaseSession()63 int32_t AudioCtrlChannel::ReleaseSession()
64 {
65 DHLOGI("Release session, peerDevId: %s", GetAnonyString(peerDevId_).c_str());
66 DAUDIO_SYNC_TRACE(DAUDIO_RELEASE_CTRL_SESSION);
67 int32_t ret = SoftbusAdapter::GetInstance().RemoveSoftbusSessionServer(PKG_NAME, sessionName_, peerDevId_);
68 if (ret != DH_SUCCESS) {
69 DHLOGE("Release softbus session failed ret: %d.", ret);
70 DAudioHisysevent::GetInstance().SysEventWriteFault(DAUDIO_OPT_FAIL, ret,
71 "daudio release softbus session failed.");
72 return ret;
73 }
74
75 ret = SoftbusAdapter::GetInstance().UnRegisterSoftbusListener(sessionName_, peerDevId_);
76 if (ret != DH_SUCCESS) {
77 DHLOGE("UnRegister softbus adapter listener failed ret: %d.", ret);
78 DAudioHisysevent::GetInstance().SysEventWriteFault(DAUDIO_OPT_FAIL, ret,
79 "daudio unRegister softbus adapter listener failed.");
80 return ret;
81 }
82 channelListener_.reset();
83
84 DHLOGI("Release softbus session success.");
85 return DH_SUCCESS;
86 }
87
OpenSession()88 int32_t AudioCtrlChannel::OpenSession()
89 {
90 DHLOGI("Open session, peerDevId: %s.", GetAnonyString(peerDevId_).c_str());
91 DaudioStartAsyncTrace(DAUDIO_OPEN_CTRL_SESSION, DAUDIO_OPEN_CTRL_SESSION_TASKID);
92 int32_t sessionId =
93 SoftbusAdapter::GetInstance().OpenSoftbusSession(sessionName_, sessionName_, peerDevId_);
94 if (sessionId < 0) {
95 DHLOGE("Open ctrl session failed, ret: %d.", sessionId);
96 DAudioHisysevent::GetInstance().SysEventWriteFault(DAUDIO_OPT_FAIL, ERR_DH_AUDIO_TRANS_ERROR,
97 "daudio open ctrl session failed.");
98 return ERR_DH_AUDIO_TRANS_ERROR;
99 }
100 sessionId_ = sessionId;
101
102 DHLOGI("Open ctrl session success, sessionId: %d.", sessionId_);
103 return DH_SUCCESS;
104 }
105
CloseSession()106 int32_t AudioCtrlChannel::CloseSession()
107 {
108 DHLOGI("Close session, sessionId: %d.", sessionId_);
109 if (sessionId_ == 0) {
110 DHLOGD("Session is already closed.");
111 return DH_SUCCESS;
112 }
113
114 DAUDIO_SYNC_TRACE(DAUDIO_CLOSE_CTRL_SESSION);
115 int32_t ret = SoftbusAdapter::GetInstance().CloseSoftbusSession(sessionId_);
116 if (ret != DH_SUCCESS) {
117 DHLOGE("Close ctrl session failed, ret: %d.", ret);
118 DAudioHisysevent::GetInstance().SysEventWriteFault(DAUDIO_OPT_FAIL, ret,
119 "daudio close ctrl session failed.");
120 return ret;
121 }
122 sessionId_ = 0;
123
124 DHLOGI("Close ctrl session success.");
125 return DH_SUCCESS;
126 }
127
SendData(const std::shared_ptr<AudioData> & data)128 int32_t AudioCtrlChannel::SendData(const std::shared_ptr<AudioData> &data)
129 {
130 (void) data;
131
132 return DH_SUCCESS;
133 }
134
SendEvent(const AudioEvent & audioEvent)135 int32_t AudioCtrlChannel::SendEvent(const AudioEvent &audioEvent)
136 {
137 DHLOGD("Send event, sessionId: %d.", sessionId_);
138 json jAudioEvent;
139 jAudioEvent[KEY_TYPE] = audioEvent.type;
140 jAudioEvent[KEY_EVENT_CONTENT] = audioEvent.content;
141 std::string message = jAudioEvent.dump();
142 int ret = SendMsg(message);
143 if (ret != DH_SUCCESS) {
144 DHLOGE("Send audio event failed ret: %d.", ret);
145 return ret;
146 }
147
148 return DH_SUCCESS;
149 }
150
SendMsg(string & message)151 int32_t AudioCtrlChannel::SendMsg(string &message)
152 {
153 DHLOGD("Start send messages.");
154 uint8_t *buf = reinterpret_cast<uint8_t *>(calloc((MSG_MAX_SIZE), sizeof(uint8_t)));
155 if (buf == nullptr) {
156 DHLOGE("Malloc memory failed.");
157 return ERR_DH_AUDIO_CTRL_CHANNEL_SEND_MSG_FAIL;
158 }
159 int32_t outLen = 0;
160 if (memcpy_s(buf, MSG_MAX_SIZE, reinterpret_cast<const uint8_t *>(message.c_str()), message.size()) != EOK) {
161 DHLOGE("Copy audio event failed.");
162 free(buf);
163 return ERR_DH_AUDIO_CTRL_CHANNEL_SEND_MSG_FAIL;
164 }
165 outLen = static_cast<int32_t>(message.size());
166 int32_t ret = SoftbusAdapter::GetInstance().SendSoftbusBytes(sessionId_, buf, outLen);
167 free(buf);
168 return ret;
169 }
170
OnSessionOpened(int32_t sessionId,int32_t result)171 void AudioCtrlChannel::OnSessionOpened(int32_t sessionId, int32_t result)
172 {
173 DHLOGI("On control session opened, sessionId: %d, result: %d.", sessionId, result);
174 if (result != 0) {
175 DHLOGE("Session open failed.");
176 return;
177 }
178
179 auto listener = channelListener_.lock();
180 if (listener == nullptr) {
181 DHLOGE("Channel listener is null.");
182 return;
183 }
184 listener->OnSessionOpened();
185 DaudioFinishAsyncTrace(DAUDIO_OPEN_CTRL_SESSION, DAUDIO_OPEN_CTRL_SESSION_TASKID);
186 sessionId_ = sessionId;
187 }
188
OnSessionClosed(int32_t sessionId)189 void AudioCtrlChannel::OnSessionClosed(int32_t sessionId)
190 {
191 DHLOGI("On control session closed, sessionId: %d.", sessionId);
192 if (sessionId_ == 0) {
193 DHLOGD("Session already closed.");
194 return;
195 }
196 auto listener = channelListener_.lock();
197 if (listener == nullptr) {
198 DHLOGE("Channel listener is null.");
199 return;
200 }
201 listener->OnSessionClosed();
202 sessionId_ = 0;
203 }
204
OnBytesReceived(int32_t sessionId,const void * data,uint32_t dataLen)205 void AudioCtrlChannel::OnBytesReceived(int32_t sessionId, const void *data, uint32_t dataLen)
206 {
207 DHLOGI("On bytes received, sessionId: %d, dataLen: %d.", sessionId, dataLen);
208 if (sessionId < 0 || data == nullptr || dataLen == 0 || dataLen > MSG_MAX_SIZE) {
209 DHLOGE("Param check failed");
210 return;
211 }
212 auto listener = channelListener_.lock();
213 if (listener == nullptr) {
214 DHLOGE("Channel listener is null.");
215 return;
216 }
217
218 uint8_t *buf = reinterpret_cast<uint8_t *>(calloc(dataLen + STR_TERM_LEN, sizeof(uint8_t)));
219 if (buf == nullptr) {
220 DHLOGE("Malloc memory failed.");
221 return;
222 }
223
224 if (memcpy_s(buf, dataLen + STR_TERM_LEN, reinterpret_cast<const uint8_t *>(data), dataLen) != EOK) {
225 DHLOGE("Received bytes data copy failed.");
226 free(buf);
227 return;
228 }
229
230 std::string message(buf, buf + dataLen);
231 DHLOGI("On bytes received message: %s.", message.c_str());
232 AudioEvent audioEvent;
233 json jParam = json::parse(message, nullptr, false);
234 if (from_audioEventJson(jParam, audioEvent) != DH_SUCCESS) {
235 DHLOGE("Get audioEvent from json failed.");
236 free(buf);
237 return;
238 }
239 free(buf);
240 DHLOGI("On bytes received end");
241
242 listener->OnEventReceived(audioEvent);
243 }
244
OnStreamReceived(int32_t sessionId,const StreamData * data,const StreamData * ext,const StreamFrameInfo * streamFrameInfo)245 void AudioCtrlChannel::OnStreamReceived(int32_t sessionId, const StreamData *data, const StreamData *ext,
246 const StreamFrameInfo *streamFrameInfo)
247 {
248 (void) sessionId;
249 (void) data;
250 (void) ext;
251 (void) streamFrameInfo;
252
253 DHLOGI("Ctrl channel not support yet.");
254 }
255
from_audioEventJson(const json & j,AudioEvent & audioEvent)256 int from_audioEventJson(const json &j, AudioEvent &audioEvent)
257 {
258 if (!JsonParamCheck(j, {KEY_TYPE, KEY_EVENT_CONTENT})) {
259 DHLOGE("Json data is illegal.");
260 return ERR_DH_AUDIO_TRANS_NULL_VALUE;
261 }
262
263 j.at(KEY_TYPE).get_to(audioEvent.type);
264 j.at(KEY_EVENT_CONTENT).get_to(audioEvent.content);
265 return DH_SUCCESS;
266 }
267 } // namespace DistributedHardware
268 } // namespace OHOS
269