1 /*
2 * Copyright (c) 2023 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 "av_sender_engine_adapter.h"
17 #include <dlfcn.h>
18
19 #include "daudio_constants.h"
20 #include "daudio_errorcode.h"
21 #include "daudio_log.h"
22 #include "daudio_util.h"
23
24 #include "av_trans_types.h"
25
26 #undef DH_LOG_TAG
27 #define DH_LOG_TAG "AVTransSenderAdapter"
28
29 namespace OHOS {
30 namespace DistributedHardware {
31 constexpr int32_t WAIT_TIMEOUT_MS = 5000;
32
Initialize(IAVEngineProvider * providerPtr,const std::string & peerDevId)33 int32_t AVTransSenderAdapter::Initialize(IAVEngineProvider *providerPtr, const std::string &peerDevId)
34 {
35 DHLOGI("Initialize!");
36 if (initialized_.load()) {
37 return DH_SUCCESS;
38 }
39 if (providerPtr == nullptr) {
40 DHLOGE("Av Transport sender engine provider ptr is null");
41 return ERR_DH_AV_TRANS_NULL_VALUE;
42 }
43 senderEngine_ = providerPtr->CreateAVSenderEngine(peerDevId);
44 if (senderEngine_ == nullptr) {
45 DHLOGE("Create av transport sender engine is null");
46 return ERR_DH_AV_TRANS_NULL_VALUE;
47 }
48 senderEngine_->RegisterSenderCallback(shared_from_this());
49 initialized_ = true;
50 return DH_SUCCESS;
51 }
52
Release()53 int32_t AVTransSenderAdapter::Release()
54 {
55 DHLOGI("Release!");
56 if (senderEngine_ != nullptr) {
57 int32_t ret = senderEngine_->Release();
58 if (ret != DH_SUCCESS) {
59 DHLOGE("Release av transport sender engine failed");
60 }
61 }
62 initialized_ = false;
63 senderEngine_ = nullptr;
64 chnCreateSuccess_ = false;
65 return DH_SUCCESS;
66 }
67
Start()68 int32_t AVTransSenderAdapter::Start()
69 {
70 DHLOGI("Start!");
71 if (senderEngine_ == nullptr) {
72 DHLOGE("Av transport sender engine is null");
73 return ERR_DH_AV_TRANS_NULL_VALUE;
74 }
75 return senderEngine_->Start();
76 }
77
Stop()78 int32_t AVTransSenderAdapter::Stop()
79 {
80 DHLOGI("Stop");
81 if (senderEngine_ == nullptr) {
82 DHLOGE("Av transport sender engine is null");
83 return ERR_DH_AV_TRANS_NULL_VALUE;
84 }
85 int32_t ret = senderEngine_->Stop();
86 if (ret != DH_SUCCESS) {
87 DHLOGE("Stop av transport sender engine failed");
88 return ERR_DH_AV_TRANS_STOP_FAILED;
89 }
90 DHLOGI("Stop Success");
91 return DH_SUCCESS;
92 }
93
CreateControlChannel(const std::string & peerDevId)94 int32_t AVTransSenderAdapter::CreateControlChannel(const std::string &peerDevId)
95 {
96 DHLOGI("createControlChannel enter, peerDevId:%s", GetAnonyString(peerDevId).c_str());
97 if (chnCreateSuccess_.load()) {
98 DHLOGI("Av transport sender channel already created");
99 return DH_SUCCESS;
100 }
101
102 if (senderEngine_ == nullptr) {
103 DHLOGE("Av transport sender engine is null");
104 return ERR_DH_AV_TRANS_NULL_VALUE;
105 }
106 std::vector<std::string> dstDevIds = {peerDevId};
107 int32_t ret = senderEngine_->CreateControlChannel(dstDevIds,
108 ChannelAttribute{TransStrategy::LOW_LATANCY_STRATEGY});
109 if (ret != DH_SUCCESS) {
110 DHLOGI("Create av transport sender channel failed, ret: %d", ret);
111 return ERR_DH_AV_TRANS_CREATE_CHANNEL_FAILED;
112 }
113 ret = WaitForChannelCreated();
114 if (ret != DH_SUCCESS) {
115 DHLOGE("Wait for create av transport sender channel failed ret: %d", ret);
116 return ERR_DH_AV_TRANS_CREATE_CHANNEL_FAILED;
117 }
118 return DH_SUCCESS;
119 }
120
SetParameter(const AVTransTag & tag,const std::string & param)121 int32_t AVTransSenderAdapter::SetParameter(const AVTransTag &tag, const std::string ¶m)
122 {
123 DHLOGI("SetParameter!");
124 if (senderEngine_ == nullptr) {
125 DHLOGE("av transport sender engine is null");
126 return ERR_DH_AV_TRANS_NULL_VALUE;
127 }
128 int32_t ret = senderEngine_->SetParameter(tag, param);
129 if (ret != DH_SUCCESS) {
130 DHLOGE("Set av transport sender parameter failed, ret: %d", ret);
131 return ERR_DH_AV_TRANS_SETUP_FAILED;
132 }
133 return DH_SUCCESS;
134 }
135
PushData(std::shared_ptr<AudioData> & audioData)136 int32_t AVTransSenderAdapter::PushData(std::shared_ptr<AudioData> &audioData)
137 {
138 if (senderEngine_ == nullptr) {
139 DHLOGE("Av transport sender engine null");
140 return ERR_DH_AV_TRANS_NULL_VALUE;
141 }
142 auto transBuffer = std::make_shared<AVTransBuffer>(MetaType::AUDIO);
143 auto bufferData = transBuffer->CreateBufferData(audioData->Size());
144 bufferData->Write(audioData->Data(), audioData->Size());
145
146 int32_t ret = senderEngine_->PushData(transBuffer);
147 if (ret != DH_SUCCESS) {
148 DHLOGI("Push data to av transport sender failed");
149 return ERR_DH_AV_TRANS_FEED_DATA_FAILED;
150 }
151 return DH_SUCCESS;
152 }
153
SendMessageToRemote(const std::shared_ptr<AVTransMessage> & message)154 int32_t AVTransSenderAdapter::SendMessageToRemote(const std::shared_ptr<AVTransMessage> &message)
155 {
156 DHLOGI("Send message to remote");
157 if (senderEngine_ == nullptr) {
158 DHLOGE("Av transport sender engine is null");
159 return ERR_DH_AV_TRANS_NULL_VALUE;
160 }
161 int32_t ret = senderEngine_->SendMessage(message);
162 if (ret != DH_SUCCESS) {
163 DHLOGE("Send Message to remote receiver engine failed, ret: %d", ret);
164 return ERR_DH_AV_TRANS_SEND_MSG_FAILED;
165 }
166 return DH_SUCCESS;
167 }
168
RegisterAdapterCallback(const std::shared_ptr<AVSenderAdapterCallback> & callback)169 int32_t AVTransSenderAdapter::RegisterAdapterCallback(const std::shared_ptr<AVSenderAdapterCallback> &callback)
170 {
171 DHLOGI("RegisterAdapterCallback");
172 if (callback == nullptr) {
173 return ERR_DH_AV_TRANS_NULL_VALUE;
174 }
175 adapterCallback_ = callback;
176 return DH_SUCCESS;
177 }
178
WaitForChannelCreated()179 int32_t AVTransSenderAdapter::WaitForChannelCreated()
180 {
181 std::unique_lock<std::mutex> lock(chnCreatedMtx_);
182 auto status = chnCreatedCondVar_.wait_for(lock, std::chrono::milliseconds(WAIT_TIMEOUT_MS));
183 if (status == std::cv_status::timeout) {
184 DHLOGI("Wait for av transport sender channel created timeout");
185 return ERR_DH_AV_TRANS_TIMEOUT;
186 }
187 if (!chnCreateSuccess_.load()) {
188 DHLOGE("Create av transport sender channel failed");
189 return ERR_DH_AV_TRANS_CREATE_CHANNEL_FAILED;
190 }
191 return DH_SUCCESS;
192 }
193
OnSenderEvent(const AVTransEvent & event)194 int32_t AVTransSenderAdapter::OnSenderEvent(const AVTransEvent &event)
195 {
196 DHLOGI("On sender event, type: %d", event.type);
197 switch (event.type) {
198 case EventType::EVENT_CHANNEL_OPEN_FAIL:
199 case EventType::EVENT_CHANNEL_OPENED: {
200 chnCreateSuccess_ = (event.type == EventType::EVENT_CHANNEL_OPENED);
201 chnCreatedCondVar_.notify_one();
202 break;
203 }
204 case EventType::EVENT_CHANNEL_CLOSED:
205 case EventType::EVENT_START_FAIL:
206 case EventType::EVENT_START_SUCCESS:
207 case EventType::EVENT_STOP_SUCCESS:
208 case EventType::EVENT_ENGINE_ERROR:
209 case EventType::EVENT_REMOTE_ERROR:
210 if (adapterCallback_ != nullptr) {
211 DHLOGI("callback on engine event.");
212 adapterCallback_->OnEngineEvent(event);
213 }
214 break;
215 default:
216 DHLOGI("Invaild event type");
217 break;
218 }
219 return DH_SUCCESS;
220 }
221
OnMessageReceived(const std::shared_ptr<AVTransMessage> & message)222 int32_t AVTransSenderAdapter::OnMessageReceived(const std::shared_ptr<AVTransMessage> &message)
223 {
224 if (adapterCallback_ != nullptr) {
225 adapterCallback_->OnEngineMessage(message);
226 }
227 return DH_SUCCESS;
228 }
229 } // namespace DistributedHardware
230 } // namespace OHOS