1 /*
2 * Copyright (C) 2021 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 "hfp_ag_system_event_processer.h"
17
18 #include "hfp_ag_defines.h"
19 #include "hfp_ag_message.h"
20 #include "hfp_ag_service.h"
21 #include "log.h"
22 #include "log_util.h"
23
24 namespace OHOS {
25 namespace bluetooth {
HfpAgSystemEventProcesser(HfpAgProfile & profile,const std::string & address)26 HfpAgSystemEventProcesser::HfpAgSystemEventProcesser(HfpAgProfile &profile, const std::string &address)
27 :profile_(profile), address_(address)
28 {
29 }
30
Start()31 void HfpAgSystemEventProcesser::Start()
32 {
33 HfpAgSystemInterface::GetInstance().Start();
34 return;
35 }
36
Stop()37 void HfpAgSystemEventProcesser::Stop()
38 {
39 HfpAgSystemInterface::GetInstance().Stop();
40 return;
41 }
42
ExecuteEventProcess(const HfpAgMessage & event)43 void HfpAgSystemEventProcesser::ExecuteEventProcess(const HfpAgMessage &event)
44 {
45 LOG_INFO("[HFP AG]%{public}s():[%{public}s]", __FUNCTION__, GetEventType(event.type_).c_str());
46 switch (event.type_) {
47 case HFP_AG_MSG_TYPE_ANSWER_CALL:
48 ProcessAnswerCallEvent();
49 break;
50 case HFP_AG_MSG_TYPE_HANGUP_CALL:
51 ProcessHangupCallEvent();
52 break;
53 case HFP_AG_MSG_TYPE_VOLUME_CHANGED:
54 ProcessHfVolumeChangedEvent(event.arg1_, event.arg3_);
55 break;
56 case HFP_AG_MSG_TYPE_DIAL_CALL:
57 ProcessDialOutCallEvent(event.str_, event.arg1_);
58 break;
59 case HFP_AG_MSG_TYPE_SEND_DTMF:
60 ProcessSendDtmfEvent(event.arg1_);
61 break;
62 case HFP_AG_MSG_TYPE_NOISE_REDUCTION:
63 ProcessNoiseReductionEvent(event.arg1_);
64 break;
65 case HFP_AG_MSG_TYPE_AT_WBS:
66 ProcessWideBandSpeechEvent(event.arg1_);
67 break;
68 case HFP_AG_MSG_TYPE_AT_CHLD:
69 ProcessHoldCallEvent(event.arg1_);
70 break;
71 case HFP_AG_MSG_TYPE_SUBSCRIBER_NUMBER_REQUEST:
72 GetSubscriberNumber();
73 break;
74 case HFP_AG_MSG_TYPE_AT_CIND:
75 GetAgIndicator();
76 break;
77 case HFP_AG_MSG_TYPE_AT_COPS:
78 GetNetworkOperator();
79 break;
80 case HFP_AG_MSG_TYPE_AT_CLCC:
81 GetCurrentCalls();
82 break;
83 case HFP_AG_MSG_TYPE_AT_UNKNOWN:
84 ProcessAtUnknownEvent(event.str_);
85 break;
86 case HFP_AG_MSG_TYPE_KEY_PRESSED:
87 ProcessKeyPressedEvent();
88 break;
89 case HFP_AG_MSG_TYPE_AT_BIND:
90 ProcessATBindEvent(event.str_);
91 break;
92 case HFP_AG_MSG_TYPE_AT_BIEV:
93 SendHfIndicator(event.arg1_, event.arg3_);
94 break;
95 case HFP_AG_MSG_TYPE_AT_BIA:
96 ProcessAtBiaEvent(event);
97 break;
98 case HFP_AG_MSG_TYPE_QUERY_AG_INDICATOR:
99 QueryAgIndicator();
100 break;
101 case HFP_AG_MSG_TYPE_VR_CHANGED:
102 VoiceRecognitionStateChanged(event.arg1_);
103 break;
104 case HFP_AG_NOTIFY_INDICATOR_EVT:
105 UpdataAgIndicator();
106 break;
107 case HFP_AG_GET_VOICE_NUMBER:
108 GetVoiceNumber();
109 break;
110 case HFP_AG_GET_BTRH_EVT:
111 GetResponseHoldState(event.dev_);
112 break;
113 case HFP_AG_SET_BTRH_EVT:
114 SetResponseHold(event.dev_, event.arg1_);
115 break;
116 case HFP_AG_CALL_STATE_CHANGE_MOCK:
117 HandlePhoneStateMock(event.state_.number, event.state_.callState, event.state_.type);
118 break;
119 default:
120 GetCurrentCalls();
121 break;
122 }
123 }
124
ProcessAnswerCallEvent() const125 void HfpAgSystemEventProcesser::ProcessAnswerCallEvent() const
126 {
127 HILOGI("[HFP AG] Answer call! address:%{public}s", GetEncryptAddr(address_).c_str());
128 systemInterface_.AnswerCall(address_);
129 }
130
ProcessHangupCallEvent() const131 void HfpAgSystemEventProcesser::ProcessHangupCallEvent() const
132 {
133 HILOGI("[HFP AG] Hang up call! address:%{public}s", GetEncryptAddr(address_).c_str());
134 systemInterface_.HangupCall(address_);
135 }
136
ProcessHfVolumeChangedEvent(int type,int volume) const137 void HfpAgSystemEventProcesser::ProcessHfVolumeChangedEvent(int type, int volume) const
138 {
139 // the devcie can't change SCO volume if it is not the active device.
140 if (HfpAgProfile::GetActiveDevice() != address_) {
141 LOG_INFO("[HFP AG]%{public}s():This device is not active!", __FUNCTION__);
142 return;
143 }
144 int flag = 1;
145 if (type == HFP_AG_VOLUME_TYPE_SPK) {
146 systemInterface_.SetStreamVolume(type, volume, flag);
147 } else if (type == HFP_AG_VOLUME_TYPE_MIC) {
148 systemInterface_.SetStreamVolume(type, volume, flag);
149 } else {
150 LOG_ERROR("[HFP AG]%{public}s():The error volume type:%{public}d", __FUNCTION__, type);
151 }
152 }
153
ProcessDialOutCallEvent(const std::string & number,int dialType)154 void HfpAgSystemEventProcesser::ProcessDialOutCallEvent(const std::string &number, int dialType)
155 {
156 std::string dialNumber;
157 if (dialType == HFP_AG_LAST_NUMBER_REDIAL) {
158 dialNumber = systemInterface_.GetLastDialNumber();
159 } else if (dialType == HFP_AG_MEMORY_DIAL) {
160 // Before phone service supply real memory dial support,
161 // use last dial number for memory dial function.
162 dialNumber = systemInterface_.GetLastDialNumber();
163 } else if (dialType == HFP_AG_NUMBER_DIAL) {
164 dialNumber = number;
165 } else {
166 LOG_ERROR("[HFP AG]%{public}s():: dialType[%{public}d] is invalid", __FUNCTION__, dialType);
167 return;
168 }
169
170 LOG_INFO("[HFP AG]%{public}s():: number[%{public}s], dialNumber[%{public}s], dialType[%{public}d]",
171 __FUNCTION__,
172 number.c_str(),
173 dialNumber.c_str(),
174 dialType);
175
176 if (dialNumber.length() == 0) {
177 profile_.SendResultCode(HFP_AG_RESULT_ERROR);
178 return;
179 }
180
181 HfpAgService *service = HfpAgService::GetService();
182
183 if (service != nullptr) {
184 if (service->DialOutCallByHf(address_)) {
185 systemInterface_.DialOutCall(address_, dialNumber);
186 } else {
187 profile_.SendResultCode(HFP_AG_RESULT_ERROR);
188 }
189 } else {
190 profile_.SendResultCode(HFP_AG_RESULT_ERROR);
191 }
192 }
193
ProcessSendDtmfEvent(int dtmf) const194 void HfpAgSystemEventProcesser::ProcessSendDtmfEvent(int dtmf) const
195 {
196 profile_.SendResultCode(HFP_AG_RESULT_OK);
197 systemInterface_.SendDtmf(dtmf, address_);
198 }
199
ProcessNoiseReductionEvent(int flag) const200 void HfpAgSystemEventProcesser::ProcessNoiseReductionEvent(int flag) const
201 {
202 std::string strValue("bt_headset_nrec+");
203 bool enable = (flag == 0) ? false : true;
204 if (enable) {
205 strValue.append("on");
206 } else {
207 strValue.append("off");
208 }
209 systemInterface_.SetAudioParameters(strValue);
210 }
211
ProcessWideBandSpeechEvent(int codec) const212 void HfpAgSystemEventProcesser::ProcessWideBandSpeechEvent(int codec) const
213 {
214 std::string strValue("bt_wbs+");
215 switch (codec) {
216 case HFP_AG_WBS_YES:
217 strValue.append("on");
218 break;
219 case HFP_AG_WBS_NONE:
220 case HFP_AG_WBS_NO:
221 strValue.append("off");
222 break;
223 default:
224 strValue.clear();
225 break;
226 }
227 systemInterface_.SetAudioParameters(strValue);
228 }
229
ProcessHoldCallEvent(int chld) const230 void HfpAgSystemEventProcesser::ProcessHoldCallEvent(int chld) const
231 {
232 bool result = systemInterface_.HoldCall(chld);
233 HfpAgService *service = HfpAgService::GetService();
234 if (service == nullptr) {
235 LOG_ERROR("[HFP AG]%{public}s():no service", __FUNCTION__);
236 return;
237 }
238 int mock = service->GetMockState();
239 if (mock != HfpAgMockState::HFP_AG_MOCK) {
240 if (result) {
241 profile_.SendResultCode(HFP_AG_RESULT_OK);
242 } else {
243 profile_.SendResultCode(HFP_AG_RESULT_ERROR);
244 }
245 }
246 }
247
GetSubscriberNumber() const248 void HfpAgSystemEventProcesser::GetSubscriberNumber() const
249 {
250 std::string number = systemInterface_.GetSubscriberNumber();
251 if (!number.empty()) {
252 int type;
253 if (number[0] == '+') {
254 type = HFP_AG_CALL_NUMBER_INTERNATIONAL;
255 } else {
256 type = HFP_AG_CALL_NUMBER_UNKNOW;
257 }
258 profile_.SendSubscriberNumberInformation(type, number);
259 profile_.SendResultCode(HFP_AG_RESULT_OK);
260 } else {
261 profile_.SendResultCode(HFP_AG_RESULT_ERROR);
262 }
263 }
264
GetAgIndicator()265 void HfpAgSystemEventProcesser::GetAgIndicator()
266 {
267 int activeNum = systemInterface_.GetActiveCallNumber();
268 int heldNum = systemInterface_.GetHeldCallNumber();
269 int callState = systemInterface_.GetCallState();
270
271 LOG_INFO("[HFP AG]%{public}s():activeNum[%{public}d], heldNum[%{public}d], callState[%{public}d]!",
272 __FUNCTION__, activeNum, heldNum, callState);
273
274 int call = HFP_AG_CALL_INACTIVE;
275 if (activeNum + heldNum > 0) {
276 call = HFP_AG_CALL_ACTIVE;
277 }
278
279 int callsetup = HFP_AG_CALLSETUP_NONE;
280 if (callState == HFP_AG_CALL_STATE_INCOMING) {
281 callsetup = HFP_AG_CALLSETUP_INCOMING;
282 } else if (callState == HFP_AG_CALL_STATE_DIALING) {
283 callsetup = HFP_AG_CALLSETUP_OUTGOING;
284 } else if (callState == HFP_AG_CALL_STATE_ALERTING) {
285 callsetup = HFP_AG_CALLSETUP_ALERTING;
286 } else {
287 LOG_ERROR("[HFP AG]%{public}s():The error state of callsetup!", __FUNCTION__);
288 }
289
290 int callheld = HFP_AG_CALLHELD_INACTIVE;
291 if (heldNum == 0) {
292 callheld = 0;
293 } else if (heldNum > 0 && activeNum > 0) {
294 callheld = HFP_AG_CALLHELD_ACTIVE;
295 } else if (heldNum > 0 && activeNum == 0) {
296 callheld = HFP_AG_CALLHELD_NOACTIVE;
297 } else {
298 LOG_ERROR("[HFP AG]%{public}s():The error state of callheld!", __FUNCTION__);
299 }
300
301 int status = systemInterface_.GetServiceState();
302 int signal = systemInterface_.GetSignalStrength();
303 int roam = systemInterface_.GetRoamState();
304 int battery = systemInterface_.GetBatteryLevel();
305
306 HfpAgProfile::CindIndicators indicators = {status, call, callsetup, callheld, signal, roam, battery};
307 profile_.ReportIndicators(indicators);
308 }
309
GetNetworkOperator() const310 void HfpAgSystemEventProcesser::GetNetworkOperator() const
311 {
312 std::string networkOperator = systemInterface_.GetNetworkOperator();
313 profile_.ReportCurrentNetworkOperator(networkOperator);
314 }
315
GetCurrentCalls() const316 void HfpAgSystemEventProcesser::GetCurrentCalls() const
317 {
318 HfpAgService *service = HfpAgService::GetService();
319 if (service != nullptr) {
320 service->SetResponseClccTimer(address_);
321 }
322 systemInterface_.QueryCurrentCallsList(address_);
323 }
324
ProcessAtUnknownEvent(const std::string & atString) const325 void HfpAgSystemEventProcesser::ProcessAtUnknownEvent(const std::string &atString) const
326 {}
327
ProcessKeyPressedEvent() const328 void HfpAgSystemEventProcesser::ProcessKeyPressedEvent() const
329 {}
330
ProcessATBindEvent(const std::string & atString) const331 void HfpAgSystemEventProcesser::ProcessATBindEvent(const std::string &atString) const
332 {}
333
SendHfIndicator(int indId,int indValue) const334 void HfpAgSystemEventProcesser::SendHfIndicator(int indId, int indValue) const
335 {
336 systemInterface_.SendHfIndicator(address_, indId, indValue);
337 }
338
ProcessAtBiaEvent(const HfpAgMessage & event)339 void HfpAgSystemEventProcesser::ProcessAtBiaEvent(const HfpAgMessage &event)
340 {
341 LOG_INFO("[HFP AG]%{public}s(): BIA command is battery[%{public}d], roam[%{public}d], "
342 "service[%{public}d], signal[%{public}d]",
343 __FUNCTION__,
344 event.data_.battery,
345 event.data_.roam,
346 event.data_.service,
347 event.data_.signal);
348 profile_.ProcessBia(event.data_.service, event.data_.roam, event.data_.signal, event.data_.battery);
349 }
350
QueryAgIndicator()351 void HfpAgSystemEventProcesser::QueryAgIndicator()
352 {
353 systemInterface_.QueryAgIndicator();
354 }
355
UpdataAgIndicator()356 void HfpAgSystemEventProcesser::UpdataAgIndicator()
357 {
358 systemInterface_.UpdateCallList();
359 systemInterface_.UpdateAgIndicator();
360 }
361
GetVoiceNumber()362 void HfpAgSystemEventProcesser::GetVoiceNumber()
363 {
364 systemInterface_.GetVoiceNumber();
365 }
366
GetResponseHoldState(std::string address)367 void HfpAgSystemEventProcesser::GetResponseHoldState(std::string address)
368 {
369 systemInterface_.GetResponseHoldState(address);
370 }
371
SetResponseHold(std::string address,int btrh)372 void HfpAgSystemEventProcesser::SetResponseHold(std::string address, int btrh)
373 {
374 systemInterface_.SetResponseHoldState(address, btrh);
375 }
376
HandlePhoneStateMock(std::string number,int state,int type)377 void HfpAgSystemEventProcesser::HandlePhoneStateMock(std::string number, int state, int type)
378 {
379 systemInterface_.HandlePhoneStateMock(number, state, type);
380 }
381
382
VoiceRecognitionStateChanged(int status)383 void HfpAgSystemEventProcesser::VoiceRecognitionStateChanged(int status)
384 {
385 HfpAgService *service = HfpAgService::GetService();
386 if (service != nullptr) {
387 if (status == HFP_AG_HF_VR_OPENED) {
388 if (service->OpenVoiceRecognitionByHf(address_)) {
389 systemInterface_.StartVoiceRecognition(address_);
390 profile_.SendResultCode(HFP_AG_RESULT_OK);
391 } else {
392 profile_.SendResultCode(HFP_AG_RESULT_ERROR);
393 }
394 } else if (status == HFP_AG_HF_VR_ClOSED) {
395 if (service->CloseVoiceRecognitionByHf(address_)) {
396 profile_.SendResultCode(HFP_AG_RESULT_OK);
397 } else {
398 profile_.SendResultCode(HFP_AG_RESULT_ERROR);
399 }
400 } else {
401 profile_.SendResultCode(HFP_AG_RESULT_ERROR);
402 }
403 } else {
404 profile_.SendResultCode(HFP_AG_RESULT_ERROR);
405 }
406 }
407
GetEventType(int type)408 std::string HfpAgSystemEventProcesser::GetEventType(int type)
409 {
410 switch (type) {
411 case HFP_AG_MSG_TYPE_TYPE_NONE:
412 return "HFP_AG_MSG_TYPE_TYPE_NONE";
413 case HFP_AG_MSG_TYPE_ANSWER_CALL:
414 return "HFP_AG_MSG_TYPE_ANSWER_CALL";
415 case HFP_AG_MSG_TYPE_HANGUP_CALL:
416 return "HFP_AG_MSG_TYPE_HANGUP_CALL";
417 case HFP_AG_MSG_TYPE_VOLUME_CHANGED:
418 return "HFP_AG_MSG_TYPE_VOLUME_CHANGED";
419 case HFP_AG_MSG_TYPE_DIAL_CALL:
420 return "HFP_AG_MSG_TYPE_DIAL_CALL";
421 case HFP_AG_MSG_TYPE_SEND_DTMF:
422 return "HFP_AG_MSG_TYPE_SEND_DTMF";
423 case HFP_AG_MSG_TYPE_NOISE_REDUCTION:
424 return "HFP_AG_MSG_TYPE_NOISE_REDUCTION";
425 case HFP_AG_MSG_TYPE_AT_WBS:
426 return "HFP_AG_MSG_TYPE_AT_WBS";
427 case HFP_AG_MSG_TYPE_AT_CHLD:
428 return "HFP_AG_MSG_TYPE_AT_CHLD";
429 case HFP_AG_MSG_TYPE_SUBSCRIBER_NUMBER_REQUEST:
430 return "HFP_AG_MSG_TYPE_SUBSCRIBER_NUMBER_REQUEST";
431 case HFP_AG_MSG_TYPE_AT_CIND:
432 return "HFP_AG_MSG_TYPE_AT_CIND";
433 case HFP_AG_MSG_TYPE_AT_COPS:
434 return "HFP_AG_MSG_TYPE_AT_COPS";
435 case HFP_AG_MSG_TYPE_AT_CLCC:
436 return "HFP_AG_MSG_TYPE_AT_CLCC";
437 case HFP_AG_MSG_TYPE_AT_UNKNOWN:
438 return "HFP_AG_MSG_TYPE_AT_UNKNOWN";
439 case HFP_AG_MSG_TYPE_KEY_PRESSED:
440 return "HFP_AG_MSG_TYPE_KEY_PRESSED";
441 case HFP_AG_MSG_TYPE_AT_BIND:
442 return "HFP_AG_MSG_TYPE_AT_BIND";
443 case HFP_AG_MSG_TYPE_AT_BIEV:
444 return "HFP_AG_MSG_TYPE_AT_BIEV";
445 case HFP_AG_MSG_TYPE_AT_BIA:
446 return "HFP_AG_MSG_TYPE_AT_BIA";
447 case HFP_AG_MSG_TYPE_QUERY_AG_INDICATOR:
448 return "HFP_AG_MSG_TYPE_QUERY_AG_INDICATOR";
449 default:
450 return "Unknown";
451 }
452 }
453 } // namespace bluetooth
454 } // namespace OHOS