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():: dialNumber length[%{public}d], dialType[%{public}d]", __FUNCTION__,
171 static_cast<int>(dialNumber.length()), dialType);
172
173 if (dialNumber.length() == 0) {
174 profile_.SendResultCode(HFP_AG_RESULT_ERROR);
175 return;
176 }
177
178 HfpAgService *service = HfpAgService::GetService();
179
180 if (service != nullptr) {
181 if (service->DialOutCallByHf(address_)) {
182 systemInterface_.DialOutCall(address_, dialNumber);
183 } else {
184 profile_.SendResultCode(HFP_AG_RESULT_ERROR);
185 }
186 } else {
187 profile_.SendResultCode(HFP_AG_RESULT_ERROR);
188 }
189 }
190
ProcessSendDtmfEvent(int dtmf) const191 void HfpAgSystemEventProcesser::ProcessSendDtmfEvent(int dtmf) const
192 {
193 profile_.SendResultCode(HFP_AG_RESULT_OK);
194 systemInterface_.SendDtmf(dtmf, address_);
195 }
196
ProcessNoiseReductionEvent(int flag) const197 void HfpAgSystemEventProcesser::ProcessNoiseReductionEvent(int flag) const
198 {
199 std::string strValue("bt_headset_nrec+");
200 bool enable = (flag == 0) ? false : true;
201 if (enable) {
202 strValue.append("on");
203 } else {
204 strValue.append("off");
205 }
206 systemInterface_.SetAudioParameters(strValue);
207 }
208
ProcessWideBandSpeechEvent(int codec) const209 void HfpAgSystemEventProcesser::ProcessWideBandSpeechEvent(int codec) const
210 {
211 std::string strValue("bt_wbs+");
212 switch (codec) {
213 case HFP_AG_WBS_YES:
214 strValue.append("on");
215 break;
216 case HFP_AG_WBS_NONE:
217 case HFP_AG_WBS_NO:
218 strValue.append("off");
219 break;
220 default:
221 strValue.clear();
222 break;
223 }
224 systemInterface_.SetAudioParameters(strValue);
225 }
226
ProcessHoldCallEvent(int chld) const227 void HfpAgSystemEventProcesser::ProcessHoldCallEvent(int chld) const
228 {
229 bool result = systemInterface_.HoldCall(chld);
230 HfpAgService *service = HfpAgService::GetService();
231 if (service == nullptr) {
232 LOG_ERROR("[HFP AG]%{public}s():no service", __FUNCTION__);
233 return;
234 }
235 int mock = service->GetMockState();
236 if (mock != HfpAgMockState::HFP_AG_MOCK) {
237 if (result) {
238 profile_.SendResultCode(HFP_AG_RESULT_OK);
239 } else {
240 profile_.SendResultCode(HFP_AG_RESULT_ERROR);
241 }
242 }
243 }
244
GetSubscriberNumber() const245 void HfpAgSystemEventProcesser::GetSubscriberNumber() const
246 {
247 std::string number = systemInterface_.GetSubscriberNumber();
248 if (!number.empty()) {
249 int type;
250 if (number[0] == '+') {
251 type = HFP_AG_CALL_NUMBER_INTERNATIONAL;
252 } else {
253 type = HFP_AG_CALL_NUMBER_UNKNOW;
254 }
255 profile_.SendSubscriberNumberInformation(type, number);
256 profile_.SendResultCode(HFP_AG_RESULT_OK);
257 } else {
258 profile_.SendResultCode(HFP_AG_RESULT_ERROR);
259 }
260 }
261
GetAgIndicator()262 void HfpAgSystemEventProcesser::GetAgIndicator()
263 {
264 int activeNum = systemInterface_.GetActiveCallNumber();
265 int heldNum = systemInterface_.GetHeldCallNumber();
266 int callState = systemInterface_.GetCallState();
267
268 LOG_INFO("[HFP AG]%{public}s():activeNum[%{public}d], heldNum[%{public}d], callState[%{public}d]!",
269 __FUNCTION__, activeNum, heldNum, callState);
270
271 int call = HFP_AG_CALL_INACTIVE;
272 if (activeNum + heldNum > 0) {
273 call = HFP_AG_CALL_ACTIVE;
274 }
275
276 int callsetup = HFP_AG_CALLSETUP_NONE;
277 if (callState == HFP_AG_CALL_STATE_INCOMING) {
278 callsetup = HFP_AG_CALLSETUP_INCOMING;
279 } else if (callState == HFP_AG_CALL_STATE_DIALING) {
280 callsetup = HFP_AG_CALLSETUP_OUTGOING;
281 } else if (callState == HFP_AG_CALL_STATE_ALERTING) {
282 callsetup = HFP_AG_CALLSETUP_ALERTING;
283 } else {
284 LOG_ERROR("[HFP AG]%{public}s():The error state of callsetup!", __FUNCTION__);
285 }
286
287 int callheld = HFP_AG_CALLHELD_INACTIVE;
288 if (heldNum == 0) {
289 callheld = 0;
290 } else if (heldNum > 0 && activeNum > 0) {
291 callheld = HFP_AG_CALLHELD_ACTIVE;
292 } else if (heldNum > 0 && activeNum == 0) {
293 callheld = HFP_AG_CALLHELD_NOACTIVE;
294 } else {
295 LOG_ERROR("[HFP AG]%{public}s():The error state of callheld!", __FUNCTION__);
296 }
297
298 int status = systemInterface_.GetServiceState();
299 int signal = systemInterface_.GetSignalStrength();
300 int roam = systemInterface_.GetRoamState();
301 int battery = systemInterface_.GetBatteryLevel();
302
303 HfpAgProfile::CindIndicators indicators = {status, call, callsetup, callheld, signal, roam, battery};
304 profile_.ReportIndicators(indicators);
305 }
306
GetNetworkOperator() const307 void HfpAgSystemEventProcesser::GetNetworkOperator() const
308 {
309 std::string networkOperator = systemInterface_.GetNetworkOperator();
310 profile_.ReportCurrentNetworkOperator(networkOperator);
311 }
312
GetCurrentCalls() const313 void HfpAgSystemEventProcesser::GetCurrentCalls() const
314 {
315 HfpAgService *service = HfpAgService::GetService();
316 if (service != nullptr) {
317 service->SetResponseClccTimer(address_);
318 }
319 systemInterface_.QueryCurrentCallsList(address_);
320 }
321
ProcessAtUnknownEvent(const std::string & atString) const322 void HfpAgSystemEventProcesser::ProcessAtUnknownEvent(const std::string &atString) const
323 {}
324
ProcessKeyPressedEvent() const325 void HfpAgSystemEventProcesser::ProcessKeyPressedEvent() const
326 {}
327
ProcessATBindEvent(const std::string & atString) const328 void HfpAgSystemEventProcesser::ProcessATBindEvent(const std::string &atString) const
329 {}
330
SendHfIndicator(int indId,int indValue) const331 void HfpAgSystemEventProcesser::SendHfIndicator(int indId, int indValue) const
332 {
333 systemInterface_.SendHfIndicator(address_, indId, indValue);
334 }
335
ProcessAtBiaEvent(const HfpAgMessage & event)336 void HfpAgSystemEventProcesser::ProcessAtBiaEvent(const HfpAgMessage &event)
337 {
338 LOG_INFO("[HFP AG]%{public}s(): BIA command is battery[%{public}d], roam[%{public}d], "
339 "service[%{public}d], signal[%{public}d]",
340 __FUNCTION__,
341 event.data_.battery,
342 event.data_.roam,
343 event.data_.service,
344 event.data_.signal);
345 profile_.ProcessBia(event.data_.service, event.data_.roam, event.data_.signal, event.data_.battery);
346 }
347
QueryAgIndicator()348 void HfpAgSystemEventProcesser::QueryAgIndicator()
349 {
350 systemInterface_.QueryAgIndicator();
351 }
352
UpdataAgIndicator()353 void HfpAgSystemEventProcesser::UpdataAgIndicator()
354 {
355 systemInterface_.UpdateCallList();
356 systemInterface_.UpdateAgIndicator();
357 }
358
GetVoiceNumber()359 void HfpAgSystemEventProcesser::GetVoiceNumber()
360 {
361 systemInterface_.GetVoiceNumber();
362 }
363
GetResponseHoldState(std::string address)364 void HfpAgSystemEventProcesser::GetResponseHoldState(std::string address)
365 {
366 systemInterface_.GetResponseHoldState(address);
367 }
368
SetResponseHold(std::string address,int btrh)369 void HfpAgSystemEventProcesser::SetResponseHold(std::string address, int btrh)
370 {
371 systemInterface_.SetResponseHoldState(address, btrh);
372 }
373
HandlePhoneStateMock(std::string number,int state,int type)374 void HfpAgSystemEventProcesser::HandlePhoneStateMock(std::string number, int state, int type)
375 {
376 systemInterface_.HandlePhoneStateMock(number, state, type);
377 }
378
379
VoiceRecognitionStateChanged(int status)380 void HfpAgSystemEventProcesser::VoiceRecognitionStateChanged(int status)
381 {
382 HfpAgService *service = HfpAgService::GetService();
383 if (service != nullptr) {
384 if (status == HFP_AG_HF_VR_OPENED) {
385 if (service->OpenVoiceRecognitionByHf(address_)) {
386 systemInterface_.StartVoiceRecognition(address_);
387 profile_.SendResultCode(HFP_AG_RESULT_OK);
388 } else {
389 profile_.SendResultCode(HFP_AG_RESULT_ERROR);
390 }
391 } else if (status == HFP_AG_HF_VR_ClOSED) {
392 if (service->CloseVoiceRecognitionByHf(address_)) {
393 profile_.SendResultCode(HFP_AG_RESULT_OK);
394 } else {
395 profile_.SendResultCode(HFP_AG_RESULT_ERROR);
396 }
397 } else {
398 profile_.SendResultCode(HFP_AG_RESULT_ERROR);
399 }
400 } else {
401 profile_.SendResultCode(HFP_AG_RESULT_ERROR);
402 }
403 }
404
GetEventType(int type)405 std::string HfpAgSystemEventProcesser::GetEventType(int type)
406 {
407 switch (type) {
408 case HFP_AG_MSG_TYPE_TYPE_NONE:
409 return "HFP_AG_MSG_TYPE_TYPE_NONE";
410 case HFP_AG_MSG_TYPE_ANSWER_CALL:
411 return "HFP_AG_MSG_TYPE_ANSWER_CALL";
412 case HFP_AG_MSG_TYPE_HANGUP_CALL:
413 return "HFP_AG_MSG_TYPE_HANGUP_CALL";
414 case HFP_AG_MSG_TYPE_VOLUME_CHANGED:
415 return "HFP_AG_MSG_TYPE_VOLUME_CHANGED";
416 case HFP_AG_MSG_TYPE_DIAL_CALL:
417 return "HFP_AG_MSG_TYPE_DIAL_CALL";
418 case HFP_AG_MSG_TYPE_SEND_DTMF:
419 return "HFP_AG_MSG_TYPE_SEND_DTMF";
420 case HFP_AG_MSG_TYPE_NOISE_REDUCTION:
421 return "HFP_AG_MSG_TYPE_NOISE_REDUCTION";
422 case HFP_AG_MSG_TYPE_AT_WBS:
423 return "HFP_AG_MSG_TYPE_AT_WBS";
424 case HFP_AG_MSG_TYPE_AT_CHLD:
425 return "HFP_AG_MSG_TYPE_AT_CHLD";
426 case HFP_AG_MSG_TYPE_SUBSCRIBER_NUMBER_REQUEST:
427 return "HFP_AG_MSG_TYPE_SUBSCRIBER_NUMBER_REQUEST";
428 case HFP_AG_MSG_TYPE_AT_CIND:
429 return "HFP_AG_MSG_TYPE_AT_CIND";
430 case HFP_AG_MSG_TYPE_AT_COPS:
431 return "HFP_AG_MSG_TYPE_AT_COPS";
432 case HFP_AG_MSG_TYPE_AT_CLCC:
433 return "HFP_AG_MSG_TYPE_AT_CLCC";
434 case HFP_AG_MSG_TYPE_AT_UNKNOWN:
435 return "HFP_AG_MSG_TYPE_AT_UNKNOWN";
436 case HFP_AG_MSG_TYPE_KEY_PRESSED:
437 return "HFP_AG_MSG_TYPE_KEY_PRESSED";
438 case HFP_AG_MSG_TYPE_AT_BIND:
439 return "HFP_AG_MSG_TYPE_AT_BIND";
440 case HFP_AG_MSG_TYPE_AT_BIEV:
441 return "HFP_AG_MSG_TYPE_AT_BIEV";
442 case HFP_AG_MSG_TYPE_AT_BIA:
443 return "HFP_AG_MSG_TYPE_AT_BIA";
444 case HFP_AG_MSG_TYPE_QUERY_AG_INDICATOR:
445 return "HFP_AG_MSG_TYPE_QUERY_AG_INDICATOR";
446 default:
447 return "Unknown";
448 }
449 }
450 } // namespace bluetooth
451 } // namespace OHOS