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