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 "call_state_processor.h"
17
18 #include "audio_control_manager.h"
19 #include "audio_scene_processor.h"
20 #include "call_object_manager.h"
21 #include "telephony_log_wrapper.h"
22
23 namespace OHOS {
24 namespace Telephony {
CallStateProcessor()25 CallStateProcessor::CallStateProcessor() {}
26
~CallStateProcessor()27 CallStateProcessor::~CallStateProcessor()
28 {
29 activeCalls_.clear();
30 alertingCalls_.clear();
31 incomingCalls_.clear();
32 holdingCalls_.clear();
33 dialingCalls_.clear();
34 }
35
AddCall(int32_t callId,TelCallState state)36 void CallStateProcessor::AddCall(int32_t callId, TelCallState state)
37 {
38 std::lock_guard<std::mutex> lock(mutex_);
39 switch (state) {
40 case TelCallState::CALL_STATUS_DIALING:
41 if (dialingCalls_.count(callId) == EMPTY_VALUE) {
42 TELEPHONY_LOGI("add call , state : dialing");
43 dialingCalls_.insert(callId);
44 }
45 break;
46 case TelCallState::CALL_STATUS_ALERTING:
47 if (alertingCalls_.count(callId) == EMPTY_VALUE) {
48 TELEPHONY_LOGI("add call , state : alerting");
49 alertingCalls_.insert(callId);
50 }
51 break;
52 case TelCallState::CALL_STATUS_WAITING:
53 case TelCallState::CALL_STATUS_INCOMING:
54 if (incomingCalls_.count(callId) == EMPTY_VALUE) {
55 TELEPHONY_LOGI("add call , state : incoming");
56 incomingCalls_.insert(callId);
57 }
58 break;
59 case TelCallState::CALL_STATUS_ACTIVE:
60 case TelCallState::CALL_STATUS_ANSWERED:
61 if (activeCalls_.count(callId) == EMPTY_VALUE) {
62 TELEPHONY_LOGI("add call , state : active");
63 activeCalls_.insert(callId);
64 }
65 break;
66 case TelCallState::CALL_STATUS_HOLDING:
67 if (holdingCalls_.count(callId) == EMPTY_VALUE) {
68 TELEPHONY_LOGI("add call , state : holding");
69 holdingCalls_.insert(callId);
70 }
71 break;
72 default:
73 break;
74 }
75 }
76
DeleteCall(int32_t callId,TelCallState state)77 void CallStateProcessor::DeleteCall(int32_t callId, TelCallState state)
78 {
79 std::lock_guard<std::mutex> lock(mutex_);
80 switch (state) {
81 case TelCallState::CALL_STATUS_DIALING:
82 if (dialingCalls_.count(callId) > EMPTY_VALUE) {
83 TELEPHONY_LOGI("erase call , state : dialing");
84 dialingCalls_.erase(callId);
85 }
86 break;
87 case TelCallState::CALL_STATUS_ALERTING:
88 if (alertingCalls_.count(callId) > EMPTY_VALUE) {
89 TELEPHONY_LOGI("erase call , state : alerting");
90 alertingCalls_.erase(callId);
91 }
92 break;
93 case TelCallState::CALL_STATUS_WAITING:
94 case TelCallState::CALL_STATUS_INCOMING:
95 if (incomingCalls_.count(callId) > EMPTY_VALUE) {
96 TELEPHONY_LOGI("erase call , state : incoming");
97 incomingCalls_.erase(callId);
98 }
99 break;
100 case TelCallState::CALL_STATUS_ACTIVE:
101 if (activeCalls_.count(callId) > EMPTY_VALUE) {
102 TELEPHONY_LOGI("erase call , state : active");
103 activeCalls_.erase(callId);
104 }
105 break;
106 case TelCallState::CALL_STATUS_HOLDING:
107 if (holdingCalls_.count(callId) > EMPTY_VALUE) {
108 TELEPHONY_LOGI("erase call , state : holding");
109 holdingCalls_.erase(callId);
110 }
111 break;
112 default:
113 break;
114 }
115 }
116
GetCallNumber(TelCallState state)117 int32_t CallStateProcessor::GetCallNumber(TelCallState state)
118 {
119 std::lock_guard<std::mutex> lock(mutex_);
120 int32_t number = EMPTY_VALUE;
121 switch (state) {
122 case TelCallState::CALL_STATUS_DIALING:
123 number = static_cast<int32_t>(dialingCalls_.size());
124 break;
125 case TelCallState::CALL_STATUS_ALERTING:
126 number = static_cast<int32_t>(alertingCalls_.size());
127 break;
128 case TelCallState::CALL_STATUS_INCOMING:
129 number = static_cast<int32_t>(incomingCalls_.size());
130 break;
131 case TelCallState::CALL_STATUS_ACTIVE:
132 number = static_cast<int32_t>(activeCalls_.size());
133 break;
134 case TelCallState::CALL_STATUS_HOLDING:
135 number = static_cast<int32_t>(holdingCalls_.size());
136 break;
137 default:
138 break;
139 }
140 return number;
141 }
142
ShouldSwitchState(TelCallState callState)143 bool CallStateProcessor::ShouldSwitchState(TelCallState callState)
144 {
145 std::lock_guard<std::mutex> lock(mutex_);
146 bool shouldSwitch = false;
147 switch (callState) {
148 case TelCallState::CALL_STATUS_DIALING:
149 shouldSwitch = (dialingCalls_.size() == EXIST_ONLY_ONE_CALL && activeCalls_.empty() &&
150 incomingCalls_.empty() && alertingCalls_.empty());
151 break;
152 case TelCallState::CALL_STATUS_ALERTING:
153 shouldSwitch = (alertingCalls_.size() == EXIST_ONLY_ONE_CALL && activeCalls_.empty() &&
154 incomingCalls_.empty() && dialingCalls_.empty());
155 break;
156 case TelCallState::CALL_STATUS_INCOMING:
157 shouldSwitch = (incomingCalls_.size() == EXIST_ONLY_ONE_CALL && activeCalls_.empty() &&
158 dialingCalls_.empty() && alertingCalls_.empty());
159 break;
160 case TelCallState::CALL_STATUS_ACTIVE:
161 shouldSwitch = (activeCalls_.size() == EXIST_ONLY_ONE_CALL);
162 break;
163 default:
164 break;
165 }
166 return shouldSwitch;
167 }
168
UpdateCurrentCallState()169 bool CallStateProcessor::UpdateCurrentCallState()
170 {
171 std::lock_guard<std::mutex> lock(mutex_);
172 if (activeCalls_.size() > EMPTY_VALUE) {
173 // no need to update call state while active calls exists
174 return false;
175 }
176 AudioEvent event = AudioEvent::UNKNOWN_EVENT;
177 if (holdingCalls_.size() > EMPTY_VALUE) {
178 event = AudioEvent::SWITCH_HOLDING_STATE;
179 } else if (incomingCalls_.size() > EMPTY_VALUE) {
180 event = AudioEvent::SWITCH_INCOMING_STATE;
181 } else if (dialingCalls_.size() > EMPTY_VALUE) {
182 event = AudioEvent::SWITCH_DIALING_STATE;
183 } else if (alertingCalls_.size() > EMPTY_VALUE) {
184 event = AudioEvent::SWITCH_ALERTING_STATE;
185 } else {
186 event = AudioEvent::SWITCH_AUDIO_INACTIVE_STATE;
187 }
188 TELEPHONY_LOGI("UpdateCurrentCallState ProcessEvent event=%{public}d", event);
189 return DelayedSingleton<AudioSceneProcessor>::GetInstance()->ProcessEvent(event);
190 }
191
ShouldStopSoundtone()192 bool CallStateProcessor::ShouldStopSoundtone()
193 {
194 std::lock_guard<std::mutex> lock(mutex_);
195 if (activeCalls_.size() > EMPTY_VALUE
196 || (incomingCalls_.size() > EMPTY_VALUE && CallObjectManager::HasIncomingCallCrsType())) {
197 // no need to stop soundtone
198 return false;
199 }
200 if (holdingCalls_.size() == EMPTY_VALUE && dialingCalls_.size() == EMPTY_VALUE &&
201 alertingCalls_.size() == EMPTY_VALUE) {
202 return true;
203 }
204 return false;
205 }
206
GetAudioForegroundLiveCall()207 int32_t CallStateProcessor::GetAudioForegroundLiveCall()
208 {
209 std::lock_guard<std::mutex> lock(mutex_);
210 int32_t callId = INVALID_CALLID;
211 if (activeCalls_.size() > EMPTY_VALUE) {
212 callId = *activeCalls_.begin();
213 } else if (dialingCalls_.size() > EMPTY_VALUE) {
214 callId = *dialingCalls_.begin();
215 } else if (alertingCalls_.size() > EMPTY_VALUE) {
216 callId = *alertingCalls_.begin();
217 } else if (incomingCalls_.size() > EMPTY_VALUE) {
218 callId = *incomingCalls_.begin();
219 } else if (holdingCalls_.size() > EMPTY_VALUE) {
220 callId = *holdingCalls_.begin();
221 }
222 return callId;
223 }
224
GetCurrentActiveCall()225 int32_t CallStateProcessor::GetCurrentActiveCall()
226 {
227 std::lock_guard<std::mutex> lock(mutex_);
228 if (activeCalls_.size() > EMPTY_VALUE) {
229 return (*activeCalls_.begin());
230 }
231 return INVALID_CALLID;
232 }
233 } // namespace Telephony
234 } // namespace OHOS